Алговики - Вклад [ru]

Перемножение плотных неособенных матриц (последовательный вещественный вариант)

2017-04-20T14:24:50Z

Algoman:

Основные авторы описания: [[Участник:Frolov|А.В.Фролов]], [[Участник:VadimVV|Вад.В.Воеводин]] ([[#Описание локальности данных и вычислений|раздел 2.2]]), [[Участник:Teplov|А.М.Теплов]] (раздел [[#Масштабируемость алгоритма и его реализации|2.4]])

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===

'''Перемножение матриц''' - одна из базовых задач в алгоритмах линейной алгебры, широко применяется в большом количестве разных методов.
Здесь мы рассмотрим умножение <math>C = AB</math>  плотных неособенных матриц (последовательный вещественный вариант), то есть тот вариант, где никак не используются ни специальный вид матрицы, ни ассоциативные свойства операции сложения<ref>В.В.Воеводин, Ю.А.Кузнецов. Матрицы и вычисления. М.: Наука, 1984.</ref>.

=== Математическое описание алгоритма ===

Исходные данные: плотная матрица <math>A</math> (элементы <math>a_{ij}</math>), плотная матрица <math>B</math> (элементы <math>b_{ij}</math>).

Вычисляемые данные: плотная матрица <math>C</math> (элементы <math>c_{ij}</math>).

Формулы метода:
:<math>
\begin{align}
c_{ij} = \sum_{k = 1}^{n} a_{ik} b_{kj}, \quad i \in [1, m], \quad i \in [1, l].
\end{align}
</math>

Существует также блочная версия метода, однако в данном описании разобран только точечный метод.

=== Вычислительное ядро алгоритма ===

Вычислительное ядро перемножения плотных неособенных матриц можно составить из множественных (всего их <math>l</math>) вычислений умножения матрицы <math>A</math> на столбцы матрицы <math>B</math>, или (при более детальном рассмотрении), из множественных (всего их <math>ml</math>) скалярных произведений строк матрицы <math>A</math> на столбцы матрицы <math>B</math>:

:<math>\sum_{k = 1}^{n} a_{ik} b_{kj}</math>

в режиме накопления или без него, в зависимости от требований задачи.

=== Макроструктура алгоритма ===

Как уже записано в [[#Вычислительное ядро алгоритма|описании ядра алгоритма]], основную часть умножения матриц составляют множественные (всего <math>ml</math>) вычисления скалярных произведений строк матрицы <math>A</math> на столбцы матрицы <math>B</math>

:<math>\sum_{k = 1}^{n} a_{ik} b_{kj}</math>

в режиме накопления или без него.

=== Схема реализации последовательного алгоритма ===

Для всех <math>i</math> от <math>1</math> до <math>m</math> и для всех <math>j</math> от <math>1</math> до <math>l</math> выполняются

:<math>c_{ij} = \sum_{k = 1}^{n} a_{ik} b_{kj}</math>

Особо отметим, что вычисления сумм вида <math>\sum_{k = 1}^{n} a_{ik} b_{kj}</math> производят в режиме накопления прибавлением к текущему (временному) значению вычисляемого элемента матрицы <math>c_{ij}</math> произведений <math>a_{ik} b_{kj}</math> для <math>k</math> от <math>1</math> до <math>n</math>, '''c возрастанием''' <math>k</math>, вначале все элементы инициализируются нулями. При суммировании "по убыванию" общая схема принципиально не отличается и потому нами не рассматривается. Другие порядки выполнения суммирования приводят к изменению параллельных свойств алгоритма и будут рассматриваться нами в отдельных описаниях.

=== Последовательная сложность алгоритма ===

Для умножения двух квадратных матриц порядка <math>n</math> (т.е. при <math>m=n=l</math>) в последовательном (наиболее быстром) варианте требуется:

* по <math>n^3</math> умножений и сложений.

Для умножения матрицы размером <math>m</math> строк на <math>n</math> столбцов на матрицу размером <math>m</math> строк на <math>n</math> столбцов в последовательном (наиболее быстром) варианте требуется:

* по <math>mnl</math> умножений и сложений.

При этом использование режима накопления требует совершения умножений и сложений в режиме двойной точности (или использования функции вроде DPROD в Фортране), что ещё больше увеличивает затраты во времени, требуемом для выполнения умножения матриц.

При классификации по последовательной сложности, таким образом, алгоритм умножения матриц относится к алгоритмам ''с кубической сложностью'' (в случае неквадратных матриц - с ''трилинейной'').

=== Информационный граф ===

Опишем [[глоссарий#Граф алгоритма|граф алгоритма]] как аналитически, так и в виде рисунка.

Граф алгоритма умножения плотных матриц состоит из одной группы вершин, расположенной в целочисленных узлах трёхмерной области, соответствующая ей операция <math>a+bc</math>.

Естественно введённые координаты области таковы:
* <math>i</math> — меняется в диапазоне от <math>1</math> до <math>m</math>, принимая все целочисленные значения;
* <math>j</math> — меняется в диапазоне от <math>1</math> до <math>l</math>, принимая все целочисленные значения;
* <math>k</math> — меняется в диапазоне от <math>1</math> до <math>n</math>, принимая все целочисленные значения.

Аргументы операции следующие:
*<math>a</math>:
** при <math>k = 1</math> константа <math>0</math>;
** при <math>k > 1</math> — результат срабатывания операции, соответствующей вершине с координатами <math>i, j, k-1</math>;
*<math>b</math> — элемент ''входных данных'', а именно <math>a_{ik}</math>;
*<math>c</math> - элемент ''входных данных'' <math>b_{kj}</math>;

Результат срабатывания операции является:
* при <math>k < n</math> - ''промежуточным данным'' алгоритма;
* при <math>k = n</math> - выходным данным <math>c_{ij}</math>.

[[file:Dense mtrx product.png|thumb|center|800px|Рисунок 1. Умножение плотных матриц с отображением выходных данных]]
 

<center>
Интерактивное изображение графа алгоритма без входных и выходных данных для случая перемножения двух квадратных матриц порядка 3 и 4
</center>

<center>
{{#widget:Algoviewer
|url=mat_mul/mat_mul_3/Algo_view_matrix3.html
|width=1300
|height=800
|border=1
}}

{{#widget:Algoviewer
|url=mat_mul/mat_mul_4/Algo_view_matrix4.html
|width=1300
|height=800
|border=1
}}
</center>

=== Ресурс параллелизма алгоритма ===

Для алгоритма умножения квадратных матриц порядка n в параллельном варианте требуется последовательно выполнить следующие ярусы:

* по <math>n</math> ярусов умножений и сложений (в каждом из ярусов — <math>n^2</math> операций).

Для умножения матрицы размером <math>m</math> строк на <math>n</math> столбцов на матрицу размером <math>n</math> строк на <math>l</math> столбцов в последовательном (наиболее быстром) варианте требуется:

* по <math>n</math> ярусов умножений и сложений (в каждом из ярусов — <math>ml</math> операций).

При этом использование режима накопления требует совершения умножений и вычитаний в режиме двойной точности, а в параллельном варианте это означает, что практически все промежуточные вычисления для выполнения алгоритма в режиме накопления должны быть двойной точности. В отличие от последовательного варианта это означает некоторое увеличение требуемой памяти.

При классификации по высоте ЯПФ, таким образом, алгоритм умножения матриц относится к алгоритмам ''с линейной сложностью''. При классификации по ширине ЯПФ его сложность также будет ''квадратичной'' (для квадратных матриц) или ''билинейной'' (для матриц общего вида).

=== Входные и выходные данные алгоритма ===

'''Входные данные''': матрица <math>A</math> (элементы <math>a_{ij}</math>), матрица <math>B</math> (элементы <math>b_{ij}</math>)).

'''Объём входных данных''': <math>mn+nl</math>

'''Выходные данные''': матрица <math>C</math> (элементы <math>c_{ij}</math>).

'''Объём выходных данных''': <math>ml</math>

=== Свойства алгоритма ===

Соотношение последовательной и параллельной сложности в случае неограниченных ресурсов, как хорошо видно, является ''квадратичным'' или ''билинейным'' (отношение кубической или трилинейной к линейной).

При этом вычислительная мощность алгоритма умножения матриц, как отношение числа операций к суммарному объему входных и выходных данных – ''линейно''.

При этом алгоритм умножения матриц полностью детерминирован. Использование другого порядка выполнения ассоциативных операций в данной версии нами не рассматривается.

== Программная реализация алгоритма ==

=== Особенности реализации последовательного алгоритма ===

В простейшем варианте алгоритм умножения матриц на Фортране можно записать так:

<source lang="fortran">

DO I = 1, M
DO J = 1, L
S = 0.
DO K = 1, N
S = S + DPROD(A(I,K), B(K,J))
END DO
C(I, J) = S
END DO
END DO
</source>
При этом для реализации режима накопления переменная <math>S</math> должна быть двойной точности.

=== Локальность данных и вычислений ===
==== Локальность реализации алгоритма ====
===== Структура обращений в память и качественная оценка локальности =====

[[file:matrmult 1.PNG|thumb|center|700px|Рисунок 2. Профили обращений для 6 вариантов перемножения матриц]]

На рис.2 представлены 6 профилей обращений для различных вариантов классического перемножения матриц (в зависимости от выбранного порядка циклов). На каждом профиле хорошо выделяются фрагменты профилей для 3-х массивов, используемых в программе. При этом порядок обращений к разным массивам во всех 6 вариантах один и тот же; т.е. взаимодействие между массивами везде устроен одинаково. В этом случае отличия в локальности задаются внутренним строением фрагментов профиля для каждого массива в отдельности.

Исходя из исходного кода, можно увидеть, что всего встречается 6 разных видов фрагментов для отдельных массивов (эти виды выделены на рис.2 зеленым). Стоит сделать два уточнения: 1) профиль для результирующего массива С всегда в 2 раза больше, поскольку к элементам этого массива всегда происходят по два обращения подряд; 2) если во внутреннем цикле используется элементы массива, то обращение к этому элементу выносится за пределы внутреннего цикла (в цикле используется скалярная переменная вместо него).

Также заранее отметим, что рисунки по профилям получаются следующим образом: строится рисунок по общему профилю, после чего из него оставляется только часть для рассматриваемого массива. Доля обращений к одному массиву может меняться, поэтому и частота обращений на каждом рисунке может в значительной степени отличаться.

Рассмотрим подробнее каждый из данных 6 фрагментов на примере массива С.

'''Фрагмент 1.''' На рис.3 показано начало фрагмента 1 (здесь и далее начало фрагмента соответствует выделенной оранжевой области на рис.2). Можно увидеть, что данный фрагмент устроен достаточно просто: выполняется перебор некоторого блока элементов массива, затем данный перебор циклически повторяется. После этого происходит переход к следующему блоку элементов массива, и выполняется тот же перебор в цикле.

Если рассмотреть фрагмент более подробно (рис.4), можно увидеть, что каждый перебор является на самом деле последовательным перебором, при этом к каждому элементу происходит обращение дважды.

В результате можно сделать вывод, что фрагмент 1 обладает высокой пространственной локальностью (из-за последовательного перебора и последовательной смены блоков перебора), а также высокой временно́й локальностью (из-за двойного обращения к элементам, а также сгруппированности всех обращений к одному элементу в рамках одного блока перебора).

[[file:matrmult 2.PNG|thumb|center|700px|Рисунок 3. Начало фрагмента 1]]
[[file:matrmult 3.PNG|thumb|center|700px|Рисунок 4. Начало фрагмента 1, первые 3 итерации]]

'''Фрагмент 2.''' На рис.5 представлено начало фрагмента 2. Видно, что данный фрагмент также представляет собой перебор элементов массива в цикле, однако в данном случае на каждой итерации цикла перебираются сразу все элементы массива, а не только элементы одного блока. При более подробном рассмотрении итерации (рис.6) видно, что здесь также происходит именно последовательный перебор, и также к каждому элементу обращение происходит дважды (поскольку это массив С).

[[file:matrmult 4.PNG|thumb|center|700px|Рисунок 5. Начало фрагмента 2]]
[[file:matrmult 5.PNG|thumb|center|700px|Рисунок 6. Начало фрагмента 2, часть первой итерации]]

Такой фрагмент также обладает высокой пространственной локальностью, однако временна́я локальность несколько ниже, чем во фрагменте 1. Это связано с тем, что на каждой итерации цикла перебираются все элементы массива, а не только отдельный блок, т.е. повторные обращения происходят реже.

'''Фрагмент 3.''' Начало данного фрагмента представлено на рисунке 7. Данный профиль является последовательным перебором всех элементов массива, однако более подробное рассмотрение показывает, что к каждому элементу происходит обращение дважды, при этом между обращениями происходит достаточно много других обращений. Это связано с указанным ранее замечанием касательно вынесения повторяющегося обращения за предел внутреннего цикла.

[[file:matrmult 6.PNG|thumb|center|700px|Рисунок 7. Начало фрагмента 3]]
[[file:matrmult 7.PNG|thumb|center|700px|Рисунок 8. Начало фрагмента 3, первые несколько обращений]]

Такой фрагмент также обладает высокой пространственной локальностью, однако очень низкой временно́й, поскольку к каждому элементу обращение происходит только два раза.

'''Фрагмент 4.''' По началу фрагмента 4 видно, что профиль снова состоит из перебора всех элементов массива, однако на этот раз перебор не последовательный, а с некоторым шагом. Также можно заметить, что на каждой новой итерации перебор с шагом начинается с элемента, индекс которого немного больше, чем на предыдущей итерации. В данном случае нет нужды рассматривать профиль более подробно, поскольку из данного рисунка можно получить всю необходимую информацию.

По сравнению с предыдущим фрагментом, данный профиль обладает более низкой пространственной локальностью, поскольку перебор элементов идет с шагом, и также очень низкой временно́й локальностью, поскольку на каждой итерации происходят обращения к новым элементам.

[[file:matrmult 8.PNG|thumb|center|700px|Рисунок 9. Начало фрагмента 4]]

'''Фрагмент 5.''' В отличие от предыдущих фрагментов, исходя из визуализации начала данного фрагмента (рис.9), сложно сделать выводы относительно структуры обращения в память. Однако более подробное рассмотрение (рис.10) показывает, что данный профиль практически идентичен профилю предыдущего фрагмента. Более того, фрагмент 5 на самом деле состоит из итерационно повторяющихся фрагментов 4.

[[file:matrmult 9.PNG|thumb|center|700px|Рисунок 10. Начало фрагмента 5]]
[[file:matrmult 10.PNG|thumb|center|700px|Рисунок 11. Начало фрагмента 5, первые несколько итераций]]

Данный фрагмент обладает по сравнению с фрагментом 4 практически такой же пространственной локальностью, однако более высокой временной локальностью. Причина в обоих случаях одна – в данном случае тот же набор обращений повторяется несколько раз.

'''Фрагмент 6.''' Данный фрагмент, представленный на рис.12 и рис.13, так же сильно напоминает фрагмент 5, но с одним отличием. Во фрагменте 5 несколько раз повторяется фрагмент 4, в рамках которого выполняется несколько итераций, и на каждой итерации внутри фрагмента 4 используются разные элементы (поскольку первый элемент сдвигается на 1). В случае данного фрагмента выполняются все те же итерации, но в перемешанном виде. Сначала выполняются все итерации, начинающиеся с одного и того же элемента; затем все итерации, который начинаются с элемента, чей индекс идет следующим; и т.д.

Такой фрагмент обладает более высокой и пространственной, и временно́й локальностью по сравнению с фрагментом 5, поскольку обращения в одним и тем же элементам расположены ближе друг к другу в профиле.

[[file:matrmult 11.PNG|thumb|center|700px|Рисунок 12. Начало фрагмента 6]]
[[file:matrmult 12.PNG|thumb|center|700px|Рисунок 13. Начало фрагмента 6, первые несколько итераций]]

В итоге можно сказать, что наиболее низкой локальностью в целом обладают фрагменты 5 и 6. Фрагмент 4 также обладает низкой локальностью, однако содержит значительно меньшее число обращений, а значит, привносит меньший вклад в общий профиль обращений. Это позволяет определить, что наименее эффективными с точки зрения работы с памятью являются варианты kji и jki, поскольку каждый из них содержит фрагменты 5 и 6. Далее идут варианты ijk и jik – в них по одному такому фрагменту. Самые лучшие варианты – ikj и kij.

===== Количественная оценка локальности =====

Основные фрагменты реализации, на основе которых были получены количественные оценки, приведены [http://git.algowiki-project.org/Voevodin/locality/blob/master/benchmarks/matrix_mult/matrix_mult.h здесь] (функция Kernel***, где *** - порядок циклов (напр., KernelIJK) ). Условия запуска описаны [http://git.algowiki-project.org/Voevodin/locality/blob/master/README.md здесь].

Первая оценка выполняется на основе характеристики daps, которая оценивает число выполненных обращений (чтений и записей) в память в секунду. Данная характеристика является аналогом оценки flops применительно к работе с памятью и является в большей степени оценкой производительности взаимодействия с памятью, чем оценкой локальности. Однако она служит хорошим источником информации, в том числе для сравнения с результатами по следующей характеристике cvg.

На рис.14 приведены значения daps для реализаций распространенных алгоритмов, отсортированные по возрастанию (чем больше daps, тем в общем случае выше производительность). Можно увидеть, что, как и предполагалось наиболее эффективными являются варианты kij,ikj. Заметно хуже результат у вариантов jik,ijk, при этом эти варианты практически равны между собой. Самый плохой результат ожидаемо у вариантов jki,kji.

[[file:matrmult daps ru.PNG|thumb|center|700px|Рисунок 14. Сравнение значений оценки daps]]

Вторая характеристика – cvg – предназначена для получения более машинно-независимой оценки локальности. Она определяет, насколько часто в программе необходимо подтягивать данные в кэш-память. Соответственно, чем меньше значение cvg, тем реже это нужно делать, тем лучше локальность.

На рис.15 приведены значения cvg для того же набора реализаций, отсортированные по убыванию (чем меньше cvg, тем в общем случае выше локальность). Относительное сравнение результатов по cvg в целом повторяет результаты daps.

[[file:matrmult cvg.PNG|thumb|center|700px|Рисунок 15. Сравнение значений оценки cvg]]

=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===
==== Масштабируемость алгоритма ====
==== Масштабируемость реализации алгоритма ====

[[file:Масштабируемость перемножения матриц производительность.png|thumb|center|700px|Рисунок 16. Параллельная реализация произведения матриц Максимальная производительность. ]]
[[file:Масштабируемость параллельной реализации перемножения матриц Эффективность.png|thumb|center|700px|Рисунок 17. Параллельная реализация произведения матриц Максимальная эффективность. ]]
Набор изменяемых параметров запуска реализации алгоритма и границы значений параметров алгоритма:
* число процессоров [4 : 1024]
* размерность матрицы [1024 : 20480]
Эффективность выполнения реализации алгоритма
* Минимальная эффективность 4,71%
* Максимальная эффективность 31,72%
Оценка масштабируемости
* По числу процессов: -0.0436 – при увеличении числа процессов эффективность убывает достаточно интенсивно на всей рассмотренной области изменений параметров запуска. Уменьшение эффективности на рассмотренной области работы параллельной программы звязано с увеличением числа пересылок с ростом числа процессов и как следствие ростом накладных расходов на организацию вычислений. Присутствует область, на которой при увеличении числа процессов эффективность возрастает, но при дальнейшем росте продолжает снижаться. Это объясняется декомпозицей данных, при которой наступает момент, когда размер матрицы позволяет блокам укладываться в КЭШ-память. Так же это подтверждает проявление этого явления, но со смещением по числу процессов, и при увеличении вычислительной сложности задачи.
* По размеру задачи: -0.0255 – при увеличении размера задачи эффективность в целом уменьшается по рассматриваемой области, хотя и менее интенсивно, чем при увеличении числа процессов. Снижение эффективности объясняется тем, что при росте вычислительной сложности существенно возрастают объемы передаваемых данных. Присутствует область возрастания эффективности, на всех рассмотренных размерах матрицы. Это объясняется тем, что при малом размере задачи данные хорошо укладываются в КЭШ память, что приводит к высокой эффективности работы приложения при малом размере задачи. При дальнейшем увеличении размера эффективность уменьшается при выходе за границы КЭШ-памяти.
* По двум направлениям: -0.000968 – при рассмотрении увеличения, как вычислительной сложности, так и числа процессов по всей рассмотренной области значений уменьшается, интенсивность уменьшения эффективности не очень высока. В совокупности с тем фактом, что разница между максимальной и минимальной эффективностью на рассмотренной области значений параметров составляет почти 25% говорит о том, что уменьшение эффективности по всей области довольно равномерное, но интенсивно лишь в не очень больших участках по площади. На остальной области значений параметров изменения эффективности не столь значительны и находятся на приблизительно одном и том же уровне.

[http://git.algowiki-project.org/Teplov/Scalability/blob/master/matrixmult/matrixmult.c Реализация алгоритма на языке C].

=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===

== Литература ==
<references />

[[Категория:Законченные статьи]]
[[Категория:Матричные операции]]

[[En:Dense matrix multiplication]]

Обсуждение участника:Novikov alexander

2016-12-20T15:41:34Z

Algoman:

== Замечания к [[Стабилизированный_метод_биспоряженных_градиентов_(BiCGSTAB)]] ==

0) нужно указать конкретный вклад (пункты) каждого автора +

1) пропущен пункт 1.5 "Схема реализации последовательного алгоритма" из-за чего сбита нумерация первой части, см [[Структура_описания_свойств_алгоритмов]] +

2) большую подпись картинки из п 1.6 следует вынести в текст самого пункта +

3) отсутствует оценка вычислительная мощности в п 1.10(1.9) +

4) список литературы оформлен неправильно - см. как сделано в [[Разложение_Холецкого_(метод_квадратного_корня)]] +

== Замечания ==

* в названии: "биспоряженных" -> "бисопряженных" - как переименовать страницу? нигде найти не могу(

[[Участник:Algoman|Algoman]] ([[Обсуждение участника:Algoman|обсуждение]]) 18:37, 20 декабря 2016 (MSK) : переименовал ([[Участник:EasyBreezy/Стабилизированный_метод_бисопряженных_градиентов_(BiCGSTAB)]])

* во врезке и в остальных местах унифицировать использование n и N +
* во врезке: объем означает всего лишь количество - не понял, что имеется ввиду?
* во врезке: странно смотрятся вместе целая часть числа и О(..)
* убрать звездочку в виде символа умножения +
* слова span, dim лучше набирать прямым шрифтом: {\rm ..} +
* описание итерационного процесса из 1.2 лучше разбросать по п.1.3-1.5 и дополнить их словесным описанием
* п.1.6: "нетрудоемкие" - лучше просто сказать что их мало +
* п.1.7 "числа на вектор" - лучше "вектора на число" +
* п.1.6 (и врезка): приведена сложность не всего алгоритма, а 1 итерации; лучше домножить на кол-во итераций +
* п.1.8: "высота/ширина матрицы" - вероятно ЯПФ матрицы
* п.1.8 (и др.): обозначения р в тексте заменять на математическое р, и т.д. +
* п.1.10: термин "вычислительная мощность" сделать отсылку в глоссарий
* п.2.4: почему же использовано такое небольшое количество процессоров? это же хорошо масштабируемый алгоритм
* п.2.4: размер матрицы [..] - с каким шагом?
* п.2.4: занумеровать рисунки
* п.2.4: добавить анализ результатов выших экспериментов
* п.2.7: существуют и другие реализации, постарайтесь добавить еще

Обсуждение участника:Novikov alexander

2016-12-20T15:37:44Z

Algoman:

== Замечания к [[Стабилизированный_метод_биспоряженных_градиентов_(BiCGSTAB)]] ==

0) нужно указать конкретный вклад (пункты) каждого автора +

1) пропущен пункт 1.5 "Схема реализации последовательного алгоритма" из-за чего сбита нумерация первой части, см [[Структура_описания_свойств_алгоритмов]] +

2) большую подпись картинки из п 1.6 следует вынести в текст самого пункта +

3) отсутствует оценка вычислительная мощности в п 1.10(1.9) +

4) список литературы оформлен неправильно - см. как сделано в [[Разложение_Холецкого_(метод_квадратного_корня)]] +

== Замечания ==

* в названии: "биспоряженных" -> "бисопряженных" - как переименовать страницу? нигде найти не могу(

[[Участник:Algoman|Algoman]] ([[Обсуждение участника:Algoman|обсуждение]]) 18:37, 20 декабря 2016 (MSK) : переименовал

* во врезке и в остальных местах унифицировать использование n и N +
* во врезке: объем означает всего лишь количество - не понял, что имеется ввиду?
* во врезке: странно смотрятся вместе целая часть числа и О(..)
* убрать звездочку в виде символа умножения +
* слова span, dim лучше набирать прямым шрифтом: {\rm ..} +
* описание итерационного процесса из 1.2 лучше разбросать по п.1.3-1.5 и дополнить их словесным описанием
* п.1.6: "нетрудоемкие" - лучше просто сказать что их мало +
* п.1.7 "числа на вектор" - лучше "вектора на число" +
* п.1.6 (и врезка): приведена сложность не всего алгоритма, а 1 итерации; лучше домножить на кол-во итераций +
* п.1.8: "высота/ширина матрицы" - вероятно ЯПФ матрицы
* п.1.8 (и др.): обозначения р в тексте заменять на математическое р, и т.д. +
* п.1.10: термин "вычислительная мощность" сделать отсылку в глоссарий
* п.2.4: почему же использовано такое небольшое количество процессоров? это же хорошо масштабируемый алгоритм
* п.2.4: размер матрицы [..] - с каким шагом?
* п.2.4: занумеровать рисунки
* п.2.4: добавить анализ результатов выших экспериментов
* п.2.7: существуют и другие реализации, постарайтесь добавить еще

Участник:EasyBreezy/Стабилизированный метод бисопряженных градиентов (BiCGSTAB)

2016-12-20T15:36:54Z

Algoman: Algoman переименовал страницу Участник:EasyBreezy/Стабилизированный метод биспоряженных градиентов (BiCGSTAB) в [[Участник:EasyBreezy/Стабилизированны…

Основные авторы описания: [[Участник:Novikov alexander|Александр Новиков (1.4, 1.6, 1.7, 2.4, 2.7, 3)]], [[Участник:EasyBreezy|Гаврилов Алексей (1.1 - 1.3, 1.5, 1.8, 1.9, 2.7, 3)]]

{{algorithm
| name = BiCGSTAB
| serial_complexity = <math> O(I * N^2) </math>, где <math> N </math> - размерность СЛАУ, <math>I</math> - количество итераций
| pf_height = <math> O(k*(6 \sqrt N + 4N + 5 \lceil \frac{N}{p} \rceil)) </math>
| pf_width = <math> 2 \sqrt N </math>
| input_data = матрица <math>A \in R^{N \times N}</math> ( <math>C^{N \times N}</math> ) и вектор правой части <math>b \in R^N</math> ( <math>C^N</math> )
| output_data = вектор решения системы <math>x \in R^N</math> ( <math>C^N</math> )
}}
== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===

:Стабилизированный метод бисопряженных градиентов, так же известный как BiCGSTAB (Biconjugate gradient stabilized method), был предложен голландским математиком Хенком ван дер Ворстом<ref>Henk A. vander Vorst, Iterative Krylov Methods for Large Linear Systems, Cambridge University Press 2003, 230p</ref> в 1992 году. Статья, в которой описывался метод, стала самым цитируемым научным трудом в области математики в 1990х годах.

:Метод появился, как ответ на задачу о построении способа решения систем линейных алгебраических уравнений произвольного вида. На момент появления BiCGSTAB уже существовали методы решения СЛАУ произвольного типа, в том числе и в комплексном пространстве, например метод бисопряженных градиентов. Однако существующие на тот момент методы либо обладали недостаточной скоростью сходимости, либо использовали в вычислениях тяжелые операции, такие как транспонирования матрицы, которые усложняли распараллеливание на многопроцессорных машинах.
:BiCGSTAB является итерационным методом решения систем линейных алгебраических уравнений. Мощь метода заключается в том, что его можно применять к матрицам общего вида, в том числе с комплексными коэффициентами. В процессе выполнения BiCGSTAB не использует для вычисления плохо распараллеливаемых операций, не допускает накопления погрешностей округления и нестабильного поведения невязки. Эти факторы выгодно отличают его от предшественников: метода бисопряженных градиентов и квадратичного метода сопряженных градиентов, из которого BiCGSTAB фактически и вытекает. К преимуществам так же можно добавить более высокую в общем случае скорость сходимости относительно ближайших конкурентов. Тем не менее, для некоторых видов СЛАУ BiCGSTAB может уступать более простым методам.<ref>Горбаченко В.И, Вычислительная линейная алгебра с примерами на MATLAB. — СПб.: БХВ-Петербург, 2011. — 320 с.: ил. — (Учебное пособие)</ref>

:Благодаря свойствам алгоритма область применения метода весьма широка. Фактически, он используется во всех задачах, где требуется решать СЛАУ, в том числе СЛАУ большой размерности, к которым сводится большое количество численных методов, применяемых при решении задач математического моделирования.

:BiCGSTAB относится к классу так называемых проекционных методов. Основная идея методов данного класса: искать итерационным способом наилучшее приближение решения в некотором подпространстве пространства <math>R^n</math>, и чем шире подпространство, в котором ищется приближение решения, тем ближе будет приближенное решение к точному на каждой итерации. В качестве такого подпространства используются пространства Крылова, порожденные матрицей системы и невязкой первого приближения: <math>K^m (A, r^0) = \rm span(r^0, Ar^0, A^2r^0, ..., A^{m-1} r^0).</math><ref>Горбаченко В.И, Вычислительная линейная алгебра с примерами на MATLAB. — СПб.: БХВ-Петербург, 2011. — 320 с.: ил. — (Учебное пособие)</ref>

:Изложим основную идею любого проекционного метода, заложенную в том числе и в BiCGSTAB. Для простоты выкладок и рассуждений здесь и далее будем считать, что матрица системы и ее правая часть вещественны. Без ограничения общности все дальнейшие рассуждения могут быть перенесены и на комплексный случай. Итак, пусть решается система <math>Ax=b</math> с невырожденной матрицей <math>A \in R^{n \times n}</math> и ненулевым вектором <math>b \in R^n</math>. Имеются два подпространства <math>K_n</math> и <math>L_n</math>. Требуется найти вектор <math>x \in K_n</math>, который обеспечивает решение системы, оптимальное относительно подпространства <math>L</math>, то есть требуется выполнение условия Петрова-Галеркина: <math>(Ax,z)=(b,z), \forall z \in L_n</math>. В данном случае вектор x называется обобщенным решением системы.

:Условие Петрова-Галеркина можно записать и через определение невязки. Пусть <math>r = b - Ax</math> - невязка, тогда условие Петрова-Галеркина перепишется в виде: <math>(b - Ax, z)=(r, z),\forall z \in L_n</math>. Это равносильно тому, что вектор невязки ортогонален пространству <math>L_n</math>.

:Пусть для СЛАУ известно некоторое приближение <math>x^0</math> точного решения <math>x^*</math>. Данное приближение требуется уточнить поправкой <math> \delta: b - Ax^0 + \delta \perp L</math>. Невязка уточненного решения имеет вид: <math>r_{new} = b - Ax^0 + \delta = r^0- A\delta</math>. Условие Петрова-Галеркина тогда можно переписать так: <math>(r_{new}, z)= r^0 - (A\delta, z) = 0, \forall z \in L</math>

:Пусть <math>\rm dim K = dim L = m, V = (v_1, ..., v_n) \in R^{n \times m}, W = (w_1, ... w_n) \in R^{n \times m}</math>, где <marh>V</math> и <math>W</math> – матрицы, столбцы которых образуют базисы пространств <math>K</math> и <math>L</math> соответственно. Пусть так же <math> \delta = Vy, z = Wq</math>, где <math>y</math> – коэффициенты разложения вектора поправки по базису пространства <math>K</math>, а <math>q</math> – коэффициенты разложения вектора <math>z</math> в пространстве <math>L</math>. Тогда новое приближение решения можно записать в виде: <math>x^1 = x^0 + \delta= x^0 + Vy</math>. Из условия ортогональности Петрова-Галеркина получаем, что: <math>(r - AVy, Wq) = (W^Tr^0 - AVy, q) = 0</math>. Поскольку <math>q \neq 0</math>, то получаем СЛАУ для вектора <math>y</math>: <math>W^TAVy = W^Tr^0</math>. Если предположить, что матрица <math>W^TAVy</math> невырождена, то вектор y однозначно определяется и равен: <math>y = W^TAV^{-1}W^Tr^0</math>. Подставляя найденные коэффициенты разложения в выражение для первого приближения получаем: <math>x^1 = x^0 + \delta = x^0 + W^TAV^{-1}W^Tr^0y</math>

:Подведем итог. Общий порядок шагов любого проекционного метода следующий:
#Выбрать пару подпространств <math>K</math> и <math>L</math>
#Найти базис V пространства K и базис W пространства <math>L</math>;
#Вычислить невязку
#Найти <math>y = W^T AV^{-1} W^T r^0</math>
#Положить <math>x = x + Vy</math>
#Если не достигнут критерий остановки итерационного процесса, то повторить алгоритм, начиная с первого шага.

:Как будет показано далее, в BiCGSTAB не требуется вычислять матрицу <math>W^T AV^{-1}</math> в явном виде.

=== Математическое описание алгоритма ===
:Рассмотрим СЛАУ с вещественными коэффициентами:
<center><math>Ax = b, A \in R^{N \times N}, b \in R^N</math></center>
<center><math></math></center>
:В основу алгоритма ложиться идея проекционного метода и использование свойства A-бисопряженности системы векторов, а именно: векторы <math>p^1, p^2, ...</math> и <math>\overline p^1, \overline p^2, ...</math> бисопряжены, если <math>(Ap^i,p^j ) = 0,</math> при <math>i \neq j</math>. Фактически, данное условие эквивалентно биортогональности относительно энергетического скалярного произведения.

:Общая концепция проекционных методов предписывает нам выбрать два подпространства. В нашем случае подпространства мы выберем два подпространства, задаваемые матрицей системы А, вектором невязки на нулевой итерации <math>r^0</math> и вектором <math>\overline r^0</math>. который выбирается из условия <math>(r^0, \overline r^0) \neq 0</math>:

<center><math>K = K^k(A, r^0), L = K^k(A, \overline r^0)</math></center>

:Метод основан на построении биортогонального базиса <math>p^0, p^1, ... p^k .. </math> пространства <math>K^k (A, r^0) </math> и вычислении поправки такой, что новое приближение на очередной итерации было бы ортогонально второму подпространству Крылова. Базисные вектора строятся до тех пор, пока не будет достигнут критерий остановки итерационного процесса, а каждое последующее приближение формируется, как сумма приближения на предыдущей итерации и найденной поправки. Критерием останова итерационного процесса является достижения невязкой значения, которое меньше некоторого наперед заданного числа <math>\epsilon</math>.

:Основной итерационный процесс задается формулами:
<center><math>x^{k + 1} = x^k + \alpha_k p_k + \omega_k s_k</math></center>
<center><math>p^{k + 1} = r^{k + 1} + \beta_k p_k - \omega_k Ap_k</math></center>
:где:
#<math>x^{k + 1}</math> - приближение на следующей итерации
#<math>x^k</math> - приближение на предыдущей итерации
#<math>p_k</math> - базисный вектор подпространства Крылова, порожденного матрице СЛАУ и невязкой
#<math>\alpha_k, \omega_k</math> - вспомогательные скаляры, определяемые для каждого шага итерации
#<math>s_k</math> - вспомогательный вектор
#<math>p^{k + 1}</math> - <math>k + 1</math>-ый базисный вектор
#<math>r^{k + 1}</math> - невязка <math>k + 1</math>-ой итерации
#<math>\beta_k</math> - вспомогательный коэффициент

:Вспомогательный вектор выражается следующим образом:
*<math>s_k = r^k - \alpha_k Ap_k</math>

:Вспомогательные коэффициенты вычисляются по формулам:
*<math>\alpha_k = \frac{(r^k, \overline r^0)}{(Ap_k, \overline r^0)}</math>
*<math>\omega_k = \frac{(As_k, s_k)}{(As_k, As_k)}</math>
*<math>\beta_k = \frac{(r^{k + 1}, \overline r^0)}{(r^k, \overline r^0)}</math>

:Подведем итог и запишем итерационный процесс
:Подготовительный этап:
#Выбирается некоторое начальное приближение <math>x^0</math>
#По выбранному приближению находится невязка <math>r^0 = b - Ax^0</math>
#Из условия <math>(r^0, \overline r^0) \neq 0</math> выбирается вектор <math>\overline r^0</math>
#Положим <math>p^0 = r^0</math>
#Устанавливаем счетчик итераций: <math>n = 0</math>
:Итерационный процесс:
#Находим <math>\alpha_k</math>
#По найденному <math>\alpha_k</math> вычисляем <math>s_k</math>
#По найденному <math>s_k</math> вычисляется вспомогательный коэффициент <math>\omega_k</math>
#Находится новое приближение <math>x^{k + 1}</math>
#Вычисляется невязка <math>r^{k + 1}</math>. Если выполнено условие <math>\parallel r^{k + 1} \parallel < \epsilon</math>, то алгоритм завершается.
#Вычисляется вспомогательный коэффициент <math>\beta_k</math>
#Вычисляется новый базисный вектор: <math>p^{k + 1}</math>
#Увеличивается номер итерации: <math>n = n + 1</math>
#Переход к первому шагу итерационного процесса.

=== Вычислительное ядро алгоритма ===
:Вычислительное ядро полностью совпадает с итерационным процессом. Подготовка к итерационному процессу в ядро не включается.

=== Макроструктура алгоритма ===
На каждой итерации алгоритма используются:
# [[Скалярное произведение векторов, вещественная версия, последовательно-параллельный вариант]] x 4 раза
# [[Умножение плотной матрицы на вектор ]] х 2 раза

===Схема реализации последовательного алгоритма===

=== Последовательная сложность алгоритма ===
:Всего в вычислительном блоке алгоритма присутствует 20 трудоемких операций: 2 операции умножения матрицы на вектор, 6 скалярных произведений и 6 сложений/вычитаний векторов и 6 умножений вектора на число.

:Каждое скалярное произведение требует <math>N</math> произведений и <math>N - 1</math> сложение, то есть <math>2N - 1</math> операции. Скалярных произведений всего 6 штук (включая поиск нормы), что дает нам <math>12N - 6</math> операций.

:Умножение матрицы размерности <math>N \times N</math> на вектор эквивалентно взятию еще <math>N</math> скаляров, и так как таких операций в вычислительном ядре 2, то дополнительно имеется еще <math>2N(2N - 1)</math> операций.

:Наконец, сложение или вычитание векторов требует <math>6N</math> соотвествующих операций. Столько же требует 6 произведений вектора на число.

:Итого: <math>2N(2N - 1) + 12N - 6 + 6N + 6N = 4N^2 + 22N - 6</math> операций за одну итерацию. Домножая это на количество итераций <math>I</math>, получаем итоговую сложность алгоритма: <math>I * (4N^2 + 22N - 6)</math>

:Имеются так же операции как, извлечение квадратного корня и деление вещественных чисел друг на друга, но они не принимаются в расчет, так как они не влияют на итоговый результат. Окончательно можно заключить, что последовательная сложность алгоритма эквивалента <math>O(I * N^2)</math>

=== Информационный граф ===
[[file:BiCGStabIterations.jpg|thumb|center|800px|<center>Информационный граф.</center>]]
На графе представлены связи между операциями, выполняющимися в первых трех итерациях метода. При выполнении большего, чем 3, количества итераций, структура каждой новой будет повторять структуру третьей. Связи между итерациями не представлены, т.к. они не важны для понимания параллельной структуры алгоритма. Серым обозначено перемножение чисел, красным - умножение числа на вектор

=== Ресурс параллелизма алгоритма ===
Основной прирост производительности параллельной версии алгоритма дает использование параллельных операций вычисления скалярного произведения, суммы векторов, а так же произведения матрицы на вектор. Каждая из операций вычисления скалярного произведения и суммы векторов, выполняемая на <math>p</math> процессорах, за счет метода сдваивания может ускориться до <math> \frac{p}{\log_2 p} </math> раз. Ускорение же умножения матрицы на вектор может достигать <math>p</math> раз.

Ширина и высота ЯПФ графа данного алгоритма напрямую зависит от конкретных реализаций макроопераций и входных данных.

Для последовательно-параллельной реализации операции взятия скалярного произведения в наиболее оптимальном случае (<math>p= \sqrt N</math>) высота будет равна <math>2 \sqrt N - 1</math>, а ширина <math>\sqrt N</math>, где <math>N</math> - это длина вектора решения.

Высота ЯПФ простейшего алгоритма умножения матрицы на вектор равна <math>2N</math>, а ширина <math>m</math>, где <math>N</math> - это уже упомянутая длина вектора(она же ширина матрицы), а m - высота матрицы.

Высота ЯПФ операции умножения вектора на число равна <math>\frac{N}{p}</math>, а ширина <math>p</math>.

Высота ЯПФ операции вычисления разности векторов = <math> \log_2 p </math>, а ширина <math>p</math>.

В конечном счете общую высоту ЯПФ одной итерации алгоритма можно оценить, как <math>6 \sqrt N-3 + 4N + 3 + 1 + 3\lceil \frac{N}{p} \rceil + 2 \lceil \frac{N}{p} \rceil = 6 \sqrt N + 4N + 5 \lceil \frac{N}{p} \rceil + 1</math>, а ширину, как <math>2 \sqrt N</math>, если не брать в рассчет проверку критерия сходимости и упрощенности первой итерации по сравнению с остальными.

=== Входные и выходные данные алгоритма ===
:Входные данные
#Матрица <math>A \in R^{N \times N}</math> ( <math>C^{N \times N}</math> )
#Вектор правой части <math>b \in R^N</math> ( <math>C^N</math> )

:Выходные данные:
#Вектор решения СЛАУ <math>x \in R^N</math> ( <math>C^N</math> )

=== Свойства алгоритма ===
:BiCGSTAB хорошо зарекомендовал себя для решения систем линейных алгебраический уравнений, поскольку обладает некоторыми важными свойствами:
#Благодаря применению подхода Петрова-Галеркина и техники ортогонализации, он численно устойчив
#Не меняется вид матрицы в процессе решения
#Эффективен для решения систем большой размерности с разреженной матрицей, поскольку в методе самая трудоемкая операция - умножение матрицы на вектор
#Лучше подходит под распределенные системы, поскольку не содержит операции транспонирования матрицы
#Применим для решения систем с несимметричными матрицами.
#Вычислительная мощность: <math>N/4</math>

== Программная реализация алгоритма ==

=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
==== Локальность реализации алгоритма ====
===== Структура обращений в память и качественная оценка локальности =====
===== Количественная оценка локальности =====
===== Анализ на основе теста Apex-Map =====
=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===
==== Масштабируемость алгоритма ====
==== Масштабируемость реализации алгоритма ====
Исследование масштабируемости реализации стабилизированного метода бисопряженных градиентов проводилось согласно [[Scalability methodology|методике]] на суперкомпьютере "Ломоносов"<ref name="Lom">Воеводин Вл., Жуматий С., Соболев С., Антонов А., Брызгалов П., Никитенко Д., Стефанов К., Воеводин Вад. Практика суперкомпьютера «Ломоносов» // Открытые системы, 2012, N 7, С. 36-39.</ref> [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета].

Набор и границы значений изменяемых [[Глоссарий#Параметры запуска|параметров запуска]] реализации алгоритма:

* число процессоров [2 : 16] с шагом 1;
* размер матрицы [262144 : 11239424].

В результате проведённых экспериментов был получен следующий диапазон [[Глоссарий#Эффективность реализации|эффективности реализации]] алгоритма:

* минимальная эффективность реализации 60,00%;
* максимальная эффективность реализации 98,33%.

На следующих рисунках приведены графики [[Глоссарий#Производительность|производительности]] и эффективности выбранной реализации стабилизированного метода бисопряженных градиентов в зависимости от изменяемых параметров запуска.

[[file:Масштабируемость параллельной реализации BiCGSTAB Производительность.png|thumb|center|700px|Параллельная реализация стабилизированного метода бисопряженных градиентов. Изменение производительности в зависимости от числа процессоров и размера матрицы.]]
[[file:Масштабируемость параллельной реализации BiCGSTAB эффективность.png|thumb|center|700px|Параллельная реализация стабилизированного метода бисопряженных градиентов. Изменение эффективности в зависимости от числа процессоров и размера матрицы.]]

[https://github.com/LLNL/hypre/blob/master/src/krylov/HYPRE_bicgstab.c Исследованная параллельная реализация на языке C]

=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===
* Параллельная реализация алгоритма, предложенная MIT: [http://ab-initio.mit.edu/~meep/meep/src/bicgstab.cpp MIT BiCGSTAB]
* Параллельная реализация алгоритма в бесплатной библиотеке, поддерживающей MPI и OpenMP, HYPRE: [http://acts.nersc.gov/hypre/ Официальная страница] [https://github.com/LLNL/hypre/blob/master/src/krylov/bicgstab.c Исходный код]
* Параллельная реализация алгоритма на CUDA в условно бесплатной библиотеке [https://developer.nvidia.com/amgx/ NVIDIA AmgX]

== Литература ==

Участник:EasyBreezy/Стабилизированный метод бисопряженных градиентов (BiCGSTAB)

2016-12-20T15:35:10Z

Algoman:

Участница:Александра/Метод встречи посередине

2016-11-22T11:54:07Z

Algoman:

{{Assignment|Algoman}}
{{algorithm
| name = Метод встречи посередине
| serial_complexity = <math>O(\sqrt n\log(n))</math>
| pf_height = <math>O(1)</math>
| pf_width = <math>O(n)</math>
| input_data = <math>O(\log(n))</math>
| output_data = <math>\log(n)</math>
}}

Автор описания: [[Участник:Александра|А.В.Батарина]]

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===
Метод "Встреча посередине" криптоанализа блочных шифров был впервые предложен в 1977 году Уитфилдом Диффи и Мартином Хеллманом <ref>(June 1977) «Exhaustive Cryptanalysis of the NBS Data Encryption Standard». Computer 10 (6): 74–84. DOI:10.1109/C-M.1977.217750</ref>. Встреча посередине используется для ускорения перебора ключей шифра за счёт увеличения требуемой памяти. Метод применим в случае каскадного построения сложного шифра из нескольких простых, другими словами, в случае последовательного применения шифрующих преобразований на разных ключах к блокам открытого текста.

В качестве примера шифра, поддающегося атаке "встреча посередине" можно привести криптоалгоритм 2DES, являющийся модификацией шифра DES. В 2DES открытый текст шифруется дважды алгоритмом DES на двух разных 56-битных ключах. Однако из-за атаки "встреча посередине" сложность перебора двойного ключа (112 бит) шифра 2DES составляет <math>2^{57}</math> вместо ожидаемых <math>2^{112}</math>.

=== Математическое описание алгоритма ===

'''Исходные данные:''' открытый текст <math>x</math>, шифртекст <math>y</math>.

Алгоритм зашифрования — композиция двух преобразований <math>T_1(x,k_1)</math> и <math>T_2(x,k_2)</math>, т.е. <math>y=T_2(T_1(x,k_1),k_2)</math>.

Алгоритм расшифрования — <math>y=T_1^{-1}(T_2^{-1}(x,k_2),k_1)</math>

'''Вычисляемые данные:''' ключи шифрования <math>k_1 \in K_1</math>, <math>k_2 \in K_2</math>, где <math>K_1, K_2</math> — множества возможных ключей.

Трудоёмкость полного перебора всех возможных пар <math>k_1,k_2</math> составляет в среднем <math>\frac{|K_1||K_2|}{2}</math>, а в худшем случае <math>|K_1||K_2|</math>. Однако используя дополнительную память, можно сократить перебор.

Предположим, что открытый текст <math>x</math> и шифртекст <math>y</math> однозначно определяют ключи <math>k_1,k_2</math>. Составим две таблицы:

<math>
\begin{align}
z_1 & =T_1(x,k_1^1) & z_1^' &=T_2^{-1}(x,k_2^1)\\\\
z_2 & =T_1(x,k_1^2) & z_2^' & =T_2^{-1}(x,k_2^2)\\
... & ................. & ... & .................... \\
z_{|K_1|} & =T_1(x,k_1^{|K_1|}) & z_{|K_1|}^' & =T_2^{-1}(x,k_2^{|K_1|})
\end{align}
</math>

Для всех <math>k_1^i \in K_1</math>, <math>k_2^j \in K_2</math>. Далее таблицы объединяются и сортируются по значениям <math>z_i,z_j^'</math>. Индексы <math>i,j</math>, при которых <math>z_i=z_j^'</math>, однозначно определяют искомую пару ключей <math>k_1=k_1^i,k_2=k_2^j</math>. Для нахождения такой пары достаточно просмотреть отсортированную таблицу один раз.

Если же пара открытый текст/шифртекст определяет ключ не единственном образом, то выходом алгоритма будет некоторое множество пар <math>k_1,k_2</math>, одна из которых является истинным ключом. Для выбора истинного ключа достаточно проверить ключи из полученного множества на других парах открытый текст/шифртекст.

==== Оптимизации ====

1. От генерации второй таблицы со значениями <math>z_j^'</math> можно отказаться, перебирая ключи <math>k_2^j</math> до того момента, когда значение <math>z_j^'</math> совпадёт с одним из значений <math>z_i</math>. В таком случае опробование ключей <math>k_2^j</math> в среднем сократится вдвое. Также вдвое сократится объём используемой памяти. Для нахождения совпадающего значения в отсортированном массиве можно применить бинарный поиск.

2. Вместо сортировки таблицы со значениями <math>z_i</math> и последующего бинарного поиска можно использовать хэш-таблицу.

=== Вычислительное ядро алгоритма ===
В случае использования хэш-таблицы достаточно большого размера основную сложность алгоритма составляет опробование ключей <math>k_1,k_2</math>.
Одним из самых трудоёмких шагов также оказывается сортировка таблицы.

=== Макроструктура алгоритма ===

Как видно из описания, атака "встреча посередине" использует (или может использовать в качестве оптимизации) следующие алгоритмы:

1. Алгоритм зашифрования/расшифрования

2. Алгоритм сортировки

3. Алгоритмы поиска, вставки в хэш-таблицу

=== Схема реализации последовательного алгоритма ===

Далее приводится последовательность действий для варианта алгоритма с генерацией одной таблицы значений <math>z_i</math>.

1. Вычислить таблицу <math>z_i</math>, записывая значения в порядке вычисления или используя хэш-таблицу

2. В случае записи значений в порядке вычисления отсортировать массив

3. Опробовать ключи <math>k_2^j</math>, ища совпадения с таблицей значений <math>z_j^'</math>. Для нахождения совпадения использовать поиск по хэш-таблице (если она есть) или бинарный поиск

=== Последовательная сложность алгоритма ===
Всюду далее считаем, что алгоритм не прекращает работу при нахождении первого совпадения, а ищет все совпадения.

1. Сложность вычисления таблиц значений <math>z_i,z_j^'</math> составит <math>O(|K_1|+|K_2|)</math> операций опробования

2. Объединение таблиц и их сортировка будет иметь сложность <math>O((|K_1|+|K_2|)\log(|K_1|+|K_2|))</math> (например, при сортировке слиянием).

3. Сложность бинарного поиска в отсортированном массиве — <math>O(log_2(|K_1|))</math> для каждого поиска

4. Сложность поиска в достаточно большой хэш-таблице составит <math>O(1)</math> для каждого поиска

Итого асимптотическая сложность алгоритма:

1. С генерацией двух таблиц — <math>O(|K_1|+|K_2|) + O((|K_1|+|K_2|)\log(|K_1|+|K_2|)) + O(|K_1|+|K_2|)=O((|K_1|+|K_2|)\log(|K_1|+|K_2|))</math>

2. C генерацией одной таблицы, сортировкой и бинарным поиском — <math>O(|K_1|) + O((|K_1|)\log(|K_1|)) + O(|K_2|\log_2(|K_1|))=O(max(|K_1|,|K_2|)\log(|K_1|))</math>

3. C генерацией одной (достаточно большой) хэш-таблицы — <math>O(|K_1|) + O(|K_2|)=O(|K_1|+|K_2|)</math>

Пусть n - количество всевозможных пар <math>k_1,k_2</math> и пусть <math>|K_1|=|K_2|</math>. В этом случае <math>|K_1|=|K_2|=\sqrt n</math>.

Тогда сложность алгоритма в первых двух пунктах составляет <math>O(\sqrt n\log(n))</math>, в третьем — <math>O(\sqrt n)</math>.

=== Информационный граф ===

Опишем информационный граф алгоритма. На вход подаётся открытый (Open) и закрытый (Close), т.е. зашифрованный, текст. Далее открытый текст шифруется (Enc) на ключах <math>k_1^i</math>, а зашифрованный расшифровывается (Dec) на ключах <math>k_2^j</math>. Далее полученные криптограммы сравниваются (Cmp) и все ключи, на которых они совпали, являются выходом алгоритма.

[[file:meet.png|thumb|center|900px|Рисунок 1. Граф алгоритма c отображением входных и выходных данных. Open — открытый текст, Close — шифртекст, Enc — операция зашифрования, Dec — операция расшифрования, Cmp — операция сравнения, Keys — вычисленные ключи]]

=== Ресурс параллелизма алгоритма ===

Как видно из информационного графа, для реализации атаки "встреча посередине" в параллельном варианте потребуются выполнение следующих двух ярусов (в предположении, что <math>|K_1|=|K_2|</math>):

1. <math>\sqrt n</math> зашифрований и столько же расшифрований

2. <math>n</math> сравнений

Таким образом, высота ЯПФ составляет 2, ширина - <math>n</math>.

=== Входные и выходные данные алгоритма ===

'''Вход:'''
На вход подаётся открытый текст <math>x</math> и шифртекст <math>y</math>, а также алгоритм зашифрования/расшифрования. В случае блочного шифра открытым текстом и шифртекстом является последовательность блоков. Для атаки "встреча посередине", как правило, берётся один блок для максимального ускорения операций зашифрования и расшифрования.

'''Выход:'''
Результатом работы алгоритма является множество пар <math>k_1^i,k_2^j</math>, для которых нашлись совпадения. Только одна из пар является настоящим ключом. Чтобы отсеять лишние, необходимо проверить все пары на блоках открытого и шифрованного текста, которые в алгоритме не использовались.

=== Свойства алгоритма ===
Соотношением последовательной и параллельной сложности алгоритма является <math>O(\sqrt n\log(n))</math>.

Будем считать, что размер входных данных (открытый текст и шифртекст) совпадает с размером ключа (на практике это сравнимые величины), а сортировка слиянием делит массивы пополам. Тогда вычислительная мощность алгоритма — <math>O(\sqrt n)</math>.

Дуги информационного графа, исходящие из вершин зашифрования и расшифрования, образуют пучки мощности <math>\sqrt n</math>, т.е. из каждой такой вершины выходит <math>\sqrt n</math> дуг. Длинных дуг в алгоритме нет. В случае поиска всех пар ключей с совпадающими криптограммами алгоритм полностью детерминирован.

== Программная реализация алгоритма ==

=== Особенности реализации последовательного алгоритма ===

=== Локальность данных и вычислений ===

=== Возможные способы и особенности параллельной реализации алгоритма ===

=== Масштабируемость алгоритма и его реализации ===
Исследование масштабируемости реализации алгоритма проводилось на суперкомпьютере "Ломоносов"<ref name="Lom">Воеводин Вл., Жуматий С., Соболев С., Антонов А., Брызгалов П., Никитенко Д., Стефанов К., Воеводин Вад. Практика суперкомпьютера «Ломоносов» // Открытые системы, 2012, N 7, С. 36-39.</ref> [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета]. Изменяемые параметры запуска:
* Размер ключа – от 8 до 20 бит с шагом 1
* Число ядер – от 1 до 8 (значения являются степенью числа 2)
Ниже представлен график зависимости [[Глоссарий#Производительность|производительности]] от числа ядер и размера ключа (размер задачи – экспоненциальная функция от размера ключа). Для измерения производительности в качестве базовой операции используется операция опробования ключа и время в секундах. Количество арифметических операций, содержащихся в операции опробования, может быть разным в зависимости от используемого алгоритма шифрования.
[[File:Масштабируемость.jpg|thumb|center|900px|Рисунок 2. Масштабируемость реализации алгоритма]]

Как видно из графика, производительность почти не изменяется в зависимости от размера задачи, в то время как зависимость производительности от числа ядер визуально близка к линейной. Это связано с тем, что алгоритм содержит большое количество независимых операций опробования ключа, синхронизация между параллельно выполняющимися опробованиями не требуется.

[https://github.com/AlBatarina/Super2016/blob/master/meet_in_the_middle/meet.c Исследованная параллельная реализация на языке C]

=== Динамические характеристики и эффективность реализации алгоритма ===

=== Выводы для классов архитектур ===

=== Существующие реализации алгоритма ===

Одна из реализаций атаки "встреча посередине" с использованием хэш-таблицы представлена в свободном доступе по ссылке [https://gist.github.com/dchest/1062437 github]

== Литература ==

<references \>

Участник:Noite/EM-алгоритм кластеризации

2016-11-21T13:16:07Z

Algoman:

{{algorithm
| name = EM-алгоритм кластеризации
| serial_complexity = <math>O(iter * N * M^2 * K)</math>
| input_data = <math>N * M + 1</math>
| output_data = <math>N</math>
| pf_height = <math>O(iter * M^2 * K)</math>
| pf_width = <math>O(iter * N)</math>
}}

Автор описания: [[Участник:Noite|Зинченко Д.А.]]

= Свойства и структура алгоритма =
== Общее описание алгоритма ==
В задачах оптимизации EM-алгоритмом называют итеративную процедуру поиска численного значения экстремума какой-либо функции. В частности, в статистике этот алгоритм используется для оценки максимального правдоподобия. Впервые название EM-алгоритм было предложено в 1977 году<ref>A. Dempster, N. Laird and D. Rubin. Maximum likelihood estimation from incomplete data. – Journal of the Royal Statistical Society, Series B, 1977, vol. 39, p. 1-38.</ref>, однако его идеи были описаны и раньше<ref name=korolev>В.Ю.Королёв. ЕМ-алгоритм, его модификации и их применение к задаче разделения смесей вероятностных распределений.</ref>.

EM-алгоритм применяется для решения задач двух типов <ref name=korolev/>:

# Анализ неполных данных (данных с пропусками).
# Оценка максимального правдоподобия в случае, если функцию правдоподобия трудно исследовать аналитически. В этом случае введение набора скрытых переменных может существенно упростить задачу.

Задача кластеризации относится к задачам второго типа. В данной статье рассматривается следующая постановка задачи кластеризации:

<source>Дано множество из N объектов, каждый из которых представляет собой точку в M-мерном метрическом пространстве. Каждому измерению пространства соответствует некоторое свойство объекта. Необходимо разбить это множество на K подмножеств (кластеров) так, чтобы, чтобы элементы каждого подмножества существенно отличались по свойствам от элементов других подмножеств.</source>

Использование алгоритма EM подразумевает следующее ''предположение об объектах'':

Пусть объекты, которые необходимо разбить на кластеры, появляются случайным образом и независимо друг от друга согласно вероятностному распределению, равному смеси (линейной комбинации) распределений кластеров. В данной статье в дальнейшем будет считаться, что распределение каждого кластера является многомерным нормальным распределением с произвольной матрицей ковариации - наиболее часто используемое предположение.

Тогда каждый объект принадлежит каждому кластеру, но с разной вероятностью. EM-алгоритм итеративно оценивает параметры распределений кластеров, максимизируя логарифмическую функцию максимального правдоподобия. После окончания работы алгоритма объект будет отнесен к кластеру, вероятность принадлежности которому максимальна. Вводимый набор скрытых переменных для каждого объекта - вероятности того, что объект принадлежит каждому из кластеров.

Итерация алгоритма состоит из двух последовательных шагов.

# (Expectation) Вычисляются новые ожидаемые значения скрытых переменных.
# (Maximization) Решается задача максимизации правдоподобия: По текущим значениям скрытых переменных обновляются параметры распределений для кластеров: математическое ожидание, дисперсия и вероятность появления объектов из кластера.

== Математическое описание алгоритма ==

''Используемые обозначения:''

<math>N</math> - количество объектов, <math>K</math> - количество кластеров, <math>M</math> - количество параметров объекта

<math>\gamma_{n,k}</math> - значения скрытых переменных

<math>N_{k}</math> - количество элементов отнесенных к кластеру <math>k</math>

<math>x_{1},...,x_N</math> - объекты

''Параметры распределений:''

<math>w_{1},...,w_{K}</math> - вероятности появления объектов из кластеров (веса кластеров), <math>\sum_{k=1}^Kw_{k}=1</math>

<math>\mu_{1},...,\mu_{K}</math> - центры гауссиан кластеров

<math>\Sigma_{1},...,\Sigma_{K}</math> - матрицы ковариации гауссиан кластеров, каждая матрица имеет размерность <math>M</math>x<math>M</math>

''Смесь распределений:''
<center><math> P(x) = \sum_{j=1}^Kw_jp(x|\mu_{j}, \Sigma_{j})</math></center>

Цель алгоритма - вычислить параметры распределений, максимизирующих логарифм функции правдоподобия:

<center><math>\ln P(x|w,\mu,\Sigma)= \sum_{n=1}^N \ln \{ \sum_{k=1}^K w_{k}p(x_{n}|\mu_{k},\Sigma_{k})\}</math>.</center>

* В начале работы алгоритма задаются параметры начального приближения:

<center><math>w_{i} = 1/K, \mu_{i} = random(x_{j}), i=1..K, j=1..N</math></center>

<center><math>\Sigma_{j,j}^{k}=\frac{1}{NK}\sum_{i=1}^N(x_{i,j} - \mu_{k,j})^2, k=1..K, j=1..M</math></center>

''Поскольку от начального приближения может сильно зависеть результат работы алгоритма, вместо инициализации кластеров случайными центрами, равными весами и диагональными матрицами ковариации, как в приведенных формулах, часто применяют другие способы (подробнее - в [[#Особенности реализации последовательного алгоритма | особенностях реализации]])''
* Далее итеративно выполняется следующая пара процедур:
** E-шаг: используя текущее значение параметров <math>w_{1},...,w_{k};\mu_{1},...,\mu_{k};\Sigma^{1},...,\Sigma^{k}</math>, вычисляем значение вектора скрытых переменных <math>\gamma</math>:<center><math>\gamma_{n,k}=\frac{w_{k}p(x_{n}|\mu_{k},\Sigma^{k})}{\sum_{j=1}^K w_{j}p(x_{n}|\mu_{j},\Sigma^{j})}, </math> знаменатель дроби - нормировочный коэффициент</center><center><math>p(x|\mu,\Sigma)=\frac{1}{{(2\pi)}^{\frac{N}{2}}\sqrt{|\Sigma|}}exp\biggl\{-\frac{1}{2}{(x-\mu)}^T{\Sigma}^{-1}(x-\mu)\biggr\}</math> - плотность <math>N</math>-мерного нормального распределения</center>
** М-шаг: переоценка параметров по текущим значениям скрытых переменных для <math>k = 1..K</math>:
<center><math>\mu^{new}_{k}=\frac{1}{N_{k}}\sum_{n=1}^N \gamma_{n,k}x_{n}</math>,</center>

<center><math>\Sigma_{new}^{k}=\frac{1}{N_{k}}\sum_{n=1}^N \gamma_{n,k} (x_{n}-\mu_{k}^{new})(x_{n}-\mu_{k}^{new})^{T}</math>,</center>

<center><math>w_{k}^{new}=\frac{N_{k}}{N}</math>, <math>N_{k}=\sum_{n=1}^N \gamma_{n,k}</math>.</center>

В EM алгоритме используется один из следующих критериев остановки:
*Норма разности векторов скрытых переменных на текущей итерации не превышает заданную константу
*Прошествие заданного количества итераций
*Изменение логарифмического правдоподобия меньше заданной константы.

== Вычислительное ядро алгоритма ==
Вычислительное ядро алгоритма состоит из двух шагов, повторяющихся каждую итерацию:
*Обновление скрытых переменных на основе текущих параметров распределений
*Обновление параметров кластеров: весов, центров и матриц ковариации

== Макроструктура алгоритма ==
Как записано в [[#Вычислительное ядро алгоритма|описании вычислительного ядра алгоритма]], основную часть алгоритма составляют итеративно проводимые макрооперации: Expectation шаг - вычисление новых значений скрытых переменных, Maximization шаг - обновление параметров кластеров. Макроструктура алгоритма представлена на рисунке 1:
[[file:EM_macro.png|thumb|center|600px|Рисунок 1: Макроструктура EM-алгоритма]]

== Схема реализации последовательного алгоритма ==
Примерная схема реализации EM алгоритма с предварительной обработкой матриц ковариации:
<source>
Инициализировать веса и центры кластеров;
Инициализировать матрицы ковариации;

// Основной цикл
Пока условие остановки не выполнено
// E-шаг
В цикле для каждого кластера
Вычислить определитель матрицы ковариации Sigma;
Вычислить обратную матрицу матрице Sigma;
В цикле для каждого объекта
В цикле для каждого кластера
Вычислить и запомнить p(x | mu, Sigma) для текущего объекта и кластера;
Просуммировать вычисленные p(x | mu, Sigma);
В цикле для каждого кластера
Обновить скрытые переменные gamma;
// M-шаг
Обновить веса w;
Обновить центры кластеров mu;
Обновить матрицы ковариации Sigma;
</source>

== Последовательная сложность алгоритма ==

Количество итераций алгоритма зависит от условия остановки, поэтому будем рассматривать сложность одной итерации.

'''Шаг E'''

Сложность вычисления определителя произвольной матрицы ковариации <math>\Sigma</math> методом Гаусса - <math>O(M^3)</math>;

Сложность вычисления матрицы, обратной произвольной матрице ковариации <math>\Sigma</math> методом Гаусса - <math>O(M^3)</math>;

Сложность предварительного вычисления определителей и обратных матриц матрицам ковариации - <math>O(K * M^3)</math>

С учетом заранее вычисленных определителей и обратных матриц сложность вычисления <math>p(x | \mu,\Sigma)</math> составит: <math>O(M^2)</math>;

Суммарно сложность шага E составит <math>O(N * M^2 * K + K * M^3)</math>

'''Шаг M'''

Сложность обновления весов кластеров <math>O(K * N)</math>;

Сложность обновления центров кластеров <math>O(K * M * N)</math>;

Сложность обновления одной матрицы ковариации <math>O(N * M)</math>;

Сложность обновления всех матриц ковариации <math>O(K * M * N)</math>;

Суммарно сложность шага M алгоритма - <math>O(K * M * N)</math>;

Таким образом, сложность одной итерации EM алгоритма для псевдокода, указанного в предыдущем разделе, составит <math>O(K * M^2 * N + K * M^3 + K * M * N)</math>.

В предположении, что размерность объектов много меньше их количества <math>M << N</math> получим сложность итерации <math>O(K * M^2 * N)</math>.

Нетрудно заметить, что вычисление определителя и обратной матрицы к произвольной матрице ковариации составляет большу́ю часть работы шага E и существенно влияет на его сложность. Поэтому эти вычисления проведены заранее - вынесены за основной цикл шага E<ref name=ParallelEMComparissonGraphLab>Henggang Cui, Jinliang Wei, Wei Dai. Parallel Implementation of Expectation-Maximization for Fast Convergence - School of Computer Science, Carnegie Mellon University. [https://users.ece.cmu.edu/~hengganc/archive/report/final.pdf]</ref>. Помимо этого сложность этих вычислений можно сократить еще сильнее, если ввести ограничения структуру матрицы ковариации <math>\Sigma</math>.

Наиболее часто используемым ограничением, позволяющим эффективно распараллеливать алгоритм<ref>Вячеслав Орешков. EМ — масштабируемый алгоритм кластеризации [https://basegroup.ru/community/articles/em]</ref>, является предположение, что матрица ковариации имеет диагональную форму. Тогда вычисление её определителя и обратной матрицы имеет сложнось <math>O(M)</math>, а суммарная сложность шага E и сложность всей итерации составит <math>O(K * M * N)</math>.

== Информационный граф ==
Макроструктура алгоритма представлена на рисунке 1 (см. [[#Макроструктура алгоритма|раздел 1.4]] статьи).

На рисунке 2 представлена схема вычислений E-шага алгоритма для одного объекта: для объекта <math>x_{i}</math> и параметров <math>w_{j}, \mu_{j}, \Sigma_{j}, j=1..K</math> по формулам [[#Математическое описание алгоритма|раздела 1.2]] вычисляются ненормированные значения скрытых переменных <math>g_{j}</math>, нормировочный коэффициент ''normСoeff'', и получаются итоговые значения <math>\gamma_{i,j}</math>.

[[file:EM_Expectation_step.png|thumb|center|400px|Рисунок 2: E-шаг EM алгоритма для одного объекта]]

На рисунке 3 представлена схема вычислений E-шага алгоритма для всех объектов: для объекта <math>x_{j}</math> и параметров-векторов <math>w, \mu, \Sigma</math> по формулам [[#Математическое описание алгоритма|раздела 1.2]] вычисляются значения скрытых переменных. <math>E_{i}, i=1..N</math> - маркооперации, E-шаги для соответствующих объектов.

[[file:EM_Expectation_step_all.png|thumb|center|400px|Рисунок 3: E-шаг EM алгоритма для всех объектов]]

На рисунке 4 представлена схема вычислений M-шага алгоритма для одного кластера: для объектов <math>x_{i}</math> и скрытых переменных <math>\gamma_{i,j}</math>, соответствующих степени принадлежности этих объектов кластеру <math>j</math>, согласно формулам шага M [[#Математическое описание алгоритма|раздела 1.2]] вычисляется нормировочный коэффициент <math>N_{j}</math> и параметры этого кластера: вес <math>w_{j}^{new}</math>, матрица ковариации <math>\Sigma_{j}^{new}</math> и центр кластера <math>\mu_{j}^{new}</math>.

[[file:EM_Maximization_step.png|thumb|center|400px|Рисунок 4: M-шаг EM алгоритма для одного кластера]]

На рисунке 5 представлена схема вычислений M-шага алгоритма для всех кластеров. <math>M_{j}, j=1..K</math> соответствует макрооперации - M-шагу для соответствующего кластера и скрытых переменных.

[[file:EM_Maximization_step_all.png|thumb|center|400px|Рисунок 5: M-шаг EM алгоритма для всех кластеров]]

== Ресурс параллелизма алгоритма ==
Из схем вычислений шагов E и M шагов алгоритма, приведенным в [[#Информационный граф|предыдущем разделе]], видно, что если размерность матрицы ковариации небольшая (тогда вычисление определителя и обратной матрицы матрице ковариации не является трудоемкой операцией), обе макрооперации EM алгоритма можно распараллеливать как по кластерам, так и по объектам.

Как правило количество кластеров, на которые нужно разбить объекты, несравнимо меньше количества объектов, поэтому распараллеливание в большинстве существующих реализаций происходит по объектам: обработка объектов по возможности равномерно распределяются по кластерам. Теоретически (если считать передачу данных между процессорами мгновенной) при наличии неограниченного числа процессоров сложность алгоритма составит <math>O(M^2 * K)</math>.

== Входные и выходные данные алгоритма ==
'''Входные данные''':
* Целое неотрицательное число <math>K</math> - количество кластеров;
* Значения координат объектов <math>x_{i}</math> - <math>N</math> объектов с <math>M</math> координатами каждый.

'''Объем входных данных''':
* <math>N * M</math> вещественных чисел (если координаты объектов - вещественные числа), <math>1</math> целое неотрицательное число.

'''Выходные данные''':
* Вектор длины <math>N</math> - для каждого объекта указан номер кластера, к которому он отнесен. Объект относится по результатам работы алгоритма тому кластеру, вероятность принадлежности которому (значение соответствующей скрытой переменной) максимальна.

'''Объем выходных данных''':
* <math>N</math> целых неотрицательных чисел.

== Свойства алгоритма ==
=== Преимущества и недостатки ===
EM-алгоритм обладает следующими преимуществами и недостатками<ref>EM алгоритм, его модификации и обобщения. machinelearning.ru [http://www.machinelearning.ru/wiki/index.php?title=EM-%D0%B0%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC]</ref>:

'''Преимущества:'''

# Слабо чувствителен к выбросам
# Прост в реализации
# Быстро сходится при удачном выборе начальных значений параметров.

'''Недостатки:'''

# Неустойчив к выбору начальных значений параметров - от них зависит как скорость сходимости, так и результат работы: алгоритм может сойтись к локальному экстремуму функции правдоподобия, который может быть существенно ниже глобального.
# Алгоритм не находит оптимальное количество кластеров. Количество кластеров, на которые нужно разбить множество объектов, является параметром алгоритма.
# При большой размерности пространства объектов выдвинутое предположение о модели их распределения может быть некорректным.

=== Влияние структуры матрицы ковариации на форму кластера ===

[[file:DifferentCovariance.png|thumb|center|800px|Рисунок 6: Влияние структуры матрицы ковариации на форму кластеров для двумерного случая. a) - матрицы ковариации являются диагональными, b) - матрицы ковариации произвольны. <ref>Mathworks: Clustering Using Gaussian Mixture Models [http://www.mathworks.com/help/stats/clustering-using-gaussian-mixture-models.html]</ref>]]

Рисунок 6 наглядно показывает, что при диагональной форме матриц ковариации полуоси эллипса (в общем случае - эллипсоида), соответствующего распределению объектов, отнесенных кластеру, параллельны осям координат объектов. В противном случае полуоси могут располагаться произвольным образом.

=== Общие свойства ===
[[глоссарий#Вычислительная мощность|''Вычислительная мощность'']] EM алгоритма равна <math>M * K * it</math>, где <math>M</math> - размерность объекта, <math>K</math> - количество кластеров, а <math>it</math> - количество итераций.

EM-алгоритм является итерационным, и число итераций в общем случае не фиксировано: оно зависит от условий остановки, начальных приближений и расположения объектов. Поэтому этот алгоритм ''недетерминированный''. По тем же причинам EM-алгоритм является ''неустойчивым''.

= Программная реализация алгоритма =

== Особенности реализации последовательного алгоритма ==
=== Инициализация параметров распределений ===
Наиболее распространены 3 способа инициализации центров распределений для EM алгоритма:
# центр распределения совпадает со случайно выбранным объектом <math>x_{i}</math>
# все наблюдения распределяются по кластерам случайным образом, а затем для каждого кластера пересчитывается цент соответствующего распределения
# центры кластеров получаются в результате работы алгоритма k-means. Использование такой инициализации оправдано тем, что k-means требует меньших вычислительных затрат и быстрее сходится<ref>EM алгоритм (пример) machinelearning.ru [http://www.machinelearning.ru/wiki/index.php?title=EM_%D0%B0%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_(%D0%BF%D1%80%D0%B8%D0%BC%D0%B5%D1%80])</ref>

== Локальность данных и вычислений ==

== Возможные способы и особенности параллельной реализации алгоритма ==

== Масштабируемость алгоритма и его реализации ==

Многие статьи<ref name=FREERIDE>Leonid Glimcher, Gagan Agrawal. Parallelising EM Algorithm on a Cluster of SMPs [http://web.cse.ohio-state.edu/~agrawal/allpapers/europar04.pdf]</ref><ref name=CV>López-de-Teruel P. E., García J. M., Acacio; The Parallel EM Algorithm and its Applications in Computer Vision [http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.4.8470&rep=rep1&type=pdf]</ref><ref name=MULTITHREAD>Sharon X. Lee, Kaleb L. Leemaqz, Geoffrey J. McLachlan. A simple multithreaded implementation of the EM algorithm for mixture models [https://arxiv.org/pdf/1606.02054.pdf]</ref><ref name=CUDA>Araújo, G.F., H.T. Macedo, M.T. Chella, C.A.E. Montesco and M.V.O. Medeiros. PARALLEL IMPLEMENTATION OF EXPECTATION-MAXIMISATION ALGORITHM FOR THE TRAINING OF GAUSSIAN MIXTURE MODELS [https://ri.ufs.br/bitstream/123456789/1764/1/ExpectationMaximisationAlgorithm.pdf]</ref>, в которых представлены параллельные реализации EM алгоритма, описывают помимо использующихся программных и аппаратных решений результаты проведенных экспериментов с данными. В качестве примера в этом разделе будут рассмотрены результаты эксперементов, проведенных со связующим программным обеспечением (''middleware'') FREERIDE<ref>Leonid Glimchera, Ruoming Jinb, Gagan Agrawala. Middleware for data mining applications on clusters and grids [http://www.cs.kent.edu/~jin/Papers/JPDC08.pdf]</ref> (FRamework for Rapid Implementation of Datamining Engines), обеспечивающим возможность распараллеливания как для систем с общей памятью (в частности, симметричных мультипроцессорных систем), так и для систем с распределенной памятью.

Эксперименты проводились на кластере машин Pentium 700MHz связанных при помощи Myrinet<ref>https://en.wikipedia.org/wiki/Myrinet</ref> LANai 7.0 на трех наборах данных:

'''а)''' 3.3 * 10^6 объектов

'''b)''' 6.2 * 10^6 объектов

'''c)''' 12.5 * 10^6 объектов

Объекты представляют собой координаты точек 10-мерного пространства.

Количество машин в кластере варьировалось от 1 до 8, при этом на каждой машине запускалось до четырех параллельных потоков.

Результаты экспериментов представлены на рисунках 7-9<ref name=FREERIDE/>:

{|align="center"
|-valign="top"
|[[file:EM_FREERIDE_experiments_a.png|thumb|center|350px|Рисунок 7: набор данных a)]]
|[[file:EM_FREERIDE_experiments_b.png|thumb|center|357px|Рисунок 8: набор данных b)]]
|[[file:EM_FREERIDE_experiments_c.png|thumb|center|351px|Рисунок 9: набор данных c)]]
|}

Несмотря на то, что используемые в данном исследовании машины, как и коммуникационная среда, сейчас не используются и считаются устаревшими, результат приведенных экспериментов наглядно показывает, что EM алгоритм хорошо параллелится, зависимость ускорения от числа узлов в кластере с небольшим количеством узлов близка к линейной, а также, что скорость работы алгоритма линейно зависит от числа объектов.

'''''Данный раздел может быть дополнен'''''

== Динамические характеристики и эффективность реализации алгоритма ==

== Выводы для классов архитектур ==

== Существующие реализации алгоритма ==
Примеры библиотек, содержащих последовательную реализацию EM-алгоритма, или отдельных реализаций:

# [http://docs.opencv.org/2.4/modules/ml/doc/expectation_maximization.html OpenCV(C++)] ([https://github.com/opencv/opencv/blob/master/modules/ml/src/em.cpp github])
# [http://www.mathworks.com/help/stats/clustering-using-gaussian-mixture-models.html Matlab]
# [http://scikit-learn.org/stable/modules/mixture.html Scikit learn (Python)]
# [http://mlpack.org/index.html MLPack(C++)]

Примеры библиотек, содержащих параллельную реализацию EM-алгоритма, или отдельных реализаций:

''Здесь приводятся как конкретные реализации, так и статьи, описывающие подходы к реализациям распараллеливания EM-алгоритма''

# [https://spark.apache.org/ Apache Spark]
# [http://accord-framework.net/ Accord.NET Framework (C#)]
# Статья об использовании FREERIDE middleware для распараллеливания EM алгоритма <ref name=FREERIDE/>
# [http://andrewharp.com/gmmcuda реализация с использованием CUDA]
# [https://github.com/Corv/CUDA-GMM-MPI еще одна реализация с использованием CUDA]
# статья об использовании параллельного EM алгоритма в задачах компьютерного зрения <ref name=CV/>
# статья о распараллеливании EM алгоритма с использованием CUDA <ref name=CUDA/>

= Литература =
<references />

Участник:ЕкатеринаКозырева/Алгоритм динамической иерархической кластеризации CHAMELEON

2016-11-21T11:27:19Z

Algoman:

{{algorithm
| name = Алгоритм динамической иерархической кластеризации CHAMELEON
| serial_complexity = <math>O(nm + n log n + m^2 log m)</math>
| input_data = <math>\frac{n (n - 1)}{2}</math>
| output_data = <math>n</math>
| pf_height = <math>O(n+ n log(n) + m^2 log (m) + m log(m))</math>
| pf_width = <math>O(n)</math>
}}

Автор описания [[Участник:ЕкатеринаКозырева|Е.А.Козырева]]
= Свойства и структура алгоритмов =

== Общее описание алгоритма ==
Алгоритм CHAMELEON был предложен в 1999 году тремя учеными из университета Миннесоты – George Karypis, Eui-Hong (Sam) Han и Vipin Kumar<ref>George Karypis, Eui-Hong (Sam) Han и Vipin Kumar, «Chameleon: Hierarchical Clustering Using Dynamic Modeling», 1999.</ref>.

Предназначен для решения задач кластеризации. Кластеризация (или кластерный анализ) — это задача разбиения множества объектов на группы, называемые кластерами. Внутри каждой группы должны оказаться «похожие» объекты, а объекты разных группы должны быть как можно более отличны.

CHAMELEON - это агломеративный иерархический алгоритм кластеризации, ключевой особенностью которого является то, что он учитывает и взаимную связность, и сходство при определении наиболее похожей пары подкластеров, основываясь на динамической модели. Это означает, что в процессе кластеризации два кластера объединяются, только если их относительная взаимная связность и относительное взаимное сходство являются высокими по отношению к внутренней взаимосвязанности кластеров и близости элементов внутри кластеров. Кроме того, CHAMELEON использует подход для моделирования степени взаимосвязанности и близости между каждой парой кластеров, который учитывает внутренние характеристики самих кластеров. Таким образом, он может автоматически адаптироваться к внутренним характеристикам объединяемых кластеров.

CHAMELEON находит кластеры в наборе данных с помощью трехфазного алгоритма. На первой фазе происходит построение графа, путём добавления рёбер по принципу k ближайших соседей. На второй фазе CHAMELEON группирует полученные элементы в множество относительно небольших подграфов. Во время третьей фазы применяется агломеративный иерархический алгоритм кластеризации, с помощью которого находятся естесственные кластеры путем многократного объединения подграфов, полученных на прошлом этапе.

[[File:Chameleon.png|1000px|thumb|center|Рисунок 1. Общая структура алгоритма CHAMELEON]]

== Математическое описание алгоритма ==

''Исходные данные'':

* Множество из n точек <math>V= {v_{ij}}</math> в метрическом пространстве, которое задано симметрической матрицей расстояний <math>A</math> размера <math>n\times n</math>.
* <math>k</math> - количество ближайших соседей для вершин, <math>k \in N, k \leq n</math>.
* <math>l</math> - наименьшее число вершин, которое может содержать наибольший подграф на 2-м этапе, <math>l \in N, l \leq n</math>.

''Обозначения'':

* <math>G = (V, E)</math> - граф, полученный путём соединения каждой точки с её <math>k</math> ближайшими соседями.

* <math>K= \{K_{i}\}</math> - разбиение множества <math>V</math> на набор попарно непересекающихся связных подмножеств, полученное в результате выполнения второй фазы алгоритма.

* <math>G_{2} = (K, E_{2})</math> - взвешенный граф, вершинами которого являются получившиеся подграфы, а ребрами - количество ребер исходного графа, соединяющих соответствующие подграфы.

* <math>C = \{C_{i}\}</math> - итоговое разбиение множества вершин графа <math>G_{2}</math> на набор кластеров.

''Вспомогательные понятия''

*<math>EC_{(C_{i},C_{j})}</math> - абсолютная взаимная связность пары кластеров <math>C_{i}, C{j}</math>. Определяется как сумма весов ребер, соединяющих вершины, принадлежащие <math>C{i}</math> c вершинами из <math>C{j}</math>. Внутренняя связность <math>EC_{(C_{i},C_{i})}</math> вычисляется как сумма ребер, входящих в разделитель, разбивающий <math>C{i}</math> на два равных подграфа.

*<math>RI_{(C_{i},C_{j})} = \frac{|EC_{(C_{i},C_{j})}|}{(|EC_{C_{i}}|+|EC_{C_{j}}|)/2}</math> - относительная взаимная связность пары кластеров <math>C_{i}, C{j}</math>

*<math>S_{EC_{(C_{i},C_{j})}}</math> - абсолютное взаимное сходство пары кластеров <math>C_{i}, C{j}</math>. Подсчитывается как среднее сходство между соединенными вершинами, принадлежащими <math>C{i}</math> и <math>C{j}</math> соответственно. Соединения обусловлены разбиением общего графа, полученного на первом этапе алгоритма.

*<math> RC_{(C_{i},C_{j})}= \frac{S_{EC_{(C_{i},C_{j})}}}{\frac{|C_{i}|}{|C_{i}+C_{j}|}*S_{EC_{(C_{i})}}+\frac{|C_{i}|}{|C_{i}+C_{j}|}*S_{EC_{(C_{j})}}}</math> - относительное взаимное сходство пары кластеров <math>C_{i}, C{j}</math>. Определяется как абсолютное сходство между этой парой кластеров, нормализованное с учетом их внутреннего сходства<ref>http://studopedia.ru/7_41934_algoritm-dinamicheskoy-ierarhicheskoy-klasterizatsii-CHAMELEON.html</ref>.

'''Первый этап'''

На первом этапе, согласно графо-ориентированному подходу, происходит построение графа <math>G = (V, E)</math> на матрице сходства объектов по принципу k ближайших соседей. Две вершины такого графа соединяет ребро, если объект, соответствующий любой из этих вершин попадает в число k наиболее близких объектов для объекта, соответствующего другой вершине из данной пары.
[[Файл:Снимок chameleon 2.png|2000px|thumb|Рисунок 2. Объекты в пространстве - слева, граф по принципу 1-го ближайшего соседа - по центру, граф по принципу 3-х ближайших соседей - справа ]]

'''Второй этап'''

Алгоритм разделяет полученный граф на множество сравнительно малых подграфов <math>K= \{K_{i}\}</math>. Разделение происходит последовательно. На каждом шаге выбирается подграф, содержащий наибольшее число вершин. Этот граф разделяется на два подграфа так, что разделитель ребер графа минимален и каждый из получаемых подграфов содержит не менее 25 % вершин исходного графа. Процесс разделения останавливается, когда наибольший подграф содержит меньше некоторого заданного числа вершин. Обычно величина этого параметра задается равной значению от 1 до 5 % от числа объектов. Полученное множество связных графов считается множеством начальных кластеров, на котором требуется провести последовательное иерархическое объединение.

'''Третий этап'''

Третий этап заключается в итеративном преобразовании множества подграфов <math>K= \{K_{i}\}</math> в множество кластеров <math>C = \{C_{i}\}</math>. Алгоритм осуществляет агломеративную иерархическую кластеризацию на основании показателей <math>EC_{(C_{i},C_{j})}</math>, <math>S_{EC_{(C_{i},C_{j})}}</math>, <math>RI_{(C_{i},C_{j})} </math>, <math> RC_{(C_{i},C_{j})}</math>. Существует две стратегии анализа показателей сходства. Первая подразумевает наличие некоторых пороговых значений <math>T_{RI}</math> и <math>T_{RC}</math>. В соответствии с этой стратегией, алгоритм для каждого кластера <math>C_{i}</math> проверяет, отвечают ли смежные (наиболее близкие) ему кластеры условиям:

*<math>RI_{(C_{i},C_{j})} \geqslant T_{RI}</math>

*<math>RC_{(C_{i},C_{j})} \geqslant T_{RC}</math>

Если более одного смежного кластера отвечает этим условиям, то алгоритм выбирает для объединения наиболее связный кластер (граф), то есть такой кластер <math>C_{j}</math>, с которым у кластера <math>C_{i}</math> получается наибольшая абсолютная взаимная связность. По завершению прохода по всем кластерам, созданные таким образом пары объединяются. Параметры <math>T_{RI}</math> и <math>T_{RC}</math> могут использоваться для изменения характеристик получаемых кластеров.

Вторая стратегия заключается в использовании специальной функции, объединяющей понятия относительной взаимной связности и относительного взаимного сходства. На каждом шаге выбираются те кластеры для объединения, которые максимизируют эту функцию:

<math>RI_{(C_{i},C_{j})}*RC_{(C_{i},C_{j})}^\alpha</math>,

где <math>\alpha</math> выбирается пользователем. Если <math>\alpha > 1 </math>, то алгоритм придает большее значение относительному взаимному сходству, а если <math>\alpha < 1 </math>, то большее значение имеет относительная взаимная связность.

''Вычисляемые данные'':

<math>U = (u_1, u_2, ..., u_n)</math> - n-мерный вектор, где <math>u_i \in N_{[C]}</math> - порядковый номер кластера, к которому принадлежит вершина i исходного множества V.

== Вычислительное ядро алгоритма ==

Алгоритм имеет три вычислительных ядра, по одному на каждый этап.

На первом этапе вычислительным ядром является процесс нахождения <math>k</math> ближайших соседей для каждой вершины, который заключается в анализе матрицы расстояний.

На втором этапе вычислительным ядром является процесс поиска подходящего разбиения очередного подграфа на два графа с минимизацией разделителя ребер графа.

На третьем этапе вычислительным ядром является расчет величин <math>EC_{(C_{i},C_{j})}</math>, <math>S_{EC_{(C_{i},C_{j})}}</math>, <math>RI_{(C_{i},C_{j})} </math>, <math> RC_{(C_{i},C_{j})}</math> для каждой пары смежных кластеров.

== Макроструктура алгоритма ==

Как уже рассказывалось ранее, алгоритм включает в себя три основных этапа, каждый из которых, по сути, является отдельным алгоритмом. Этапы выполняются последовательно относительно друг друга.

Макрооперация на первом этапе - процедура нахождения <math>k</math> ближайших соседей, на втором - процедура разбиения наибольшего подграфа на два графа, на третьем - процедура вычисления показателей сходства, на основе которых принимается решение о слиянии подграфов в кластер.

== Схема реализации последовательного алгоритма ==

'''Первый этап'''
<source lang="cpp">
int n; //количество вершин
int k; //количество соседей
int A[n][n] //матрица расстояний
int D[k] //массив вершин-соседей
int E[n][n] //матрица ребер графа <math>G_{2} = (K, E_{2})</math>
for i=1 to n-1 do
{
for j=i+1 to n do
{
//заполняем массив вершин-соседей вставляя новые вершины, если они ближе, чем самая далекая из массива.
}
for j=0 to k do
{
//для каждой вершины соседа заполняем соответствующую ячейку из матрицы E[n][n] единицей
}

}
</source>

'''Второй этап'''

1. Все связные подграфы в отсортированном порядке помещаются в список;
2. Берем наибольший элемент списка, вычисляем количество его вершин. Если число вершин > l, то идем в пункт 3. Иначе в пункт 5;
3. Разбиваем подграф на два подграфа таким образом, чтобы разделитель ребер графа был минимален и каждый из получаемых подграфов содержал не менее 25 % вершин исходного графа;
4. Добавляем полученные элементы в список подграфов таким образом, чтобы список оставался отсортированным. Идем в пункт 2;
5. Нашли искомое множество подграфов math>K = \{K_{i}\}</math>;
6. Создаем и заполняем матрицу матрицу расстояний для графа <math>G_{2} = (K, E_{2})</math>. Получаем искомый набор рёбер <math>E_{2}</math>.

'''Третий этап'''

1. Заводим два массива: а) массив кластеров C, полученных на предыдущем этапе, б) массив объединений кластеров F, которые мы будем получать на этом этапе;
2. Берем следующий кластер <math>C_{i}</math> (на первом шаге - первый). Если все кластеры просмотрены, идем в пункт 6;
3. Берем следующий кластер <math>C_{j}, i<>j</math>. Если все кластеры просмотрены, то идем в пункт 2;
4. Проверяем смежность <math>C_{i}</math> и <math>C_{j}</math>. Если не смежны, то возвращаемся в пункт 3. Если смежны, идем в пункт 5;
5. Рассчитываем показатели <math>RI_{(C_{i},C_{j})}</math> и <math> RC_{(C_{i},C_{j})}</math>. Проверяем, удовлетворяют ли найденные значения условиям:
*<math>RI_{(C_{i},C_{j})} \geqslant T_{RI}</math>
*<math>RC_{(C_{i},C_{j})} \geqslant T_{RC}</math>
Если нет, то идем в пункт 3. Иначе если смежность пары кластеров выше, чем у предыдущих найденных, то <math>F_{i}=j</math>. Идем в пункт 3;
6. Если в списке F есть хотя бы одна пара кластеров для слияния, то выполняем слияние, обновляем массив кластеров и массив объединений кластеров. Идем в пункт 2.

== Последовательная сложность алгоритма ==

1) Для построения графа на основе метода k ближайших соседей для n вершин требуется <math>O(n log(n))</math> операций <ref>J.H. Friedman, J.L. Bentley, and R.A. Finkel. An algorithm for ﬁnding best matches in logarithmic expected time. ACM Transactions on Mathematical Software, 3:209–226, 1977.</ref>; для наборов данных большой размерности эта величина составляет <math>O(n^2)</math> операций <ref>S. Berchtold, C. Bohm, D. Keim, and H.-P. Kriegel. Cost model for nearest neighbor search in high dimensional data space. In Proc. of Symposium on Principles of Database Systems, Tucson, Arizona, 1997.</ref>;

2) Для выделения множества сравнительно малых связных подграфов требуется <math>nm</math> операций, где <math>m</math> - количество подграфов, полученных на втором этапе алгоритма;

3) Формирование набора кластеров, на основе множества подграфов, полученных на предыдущем этапе, требует <math>m^2log(m)</math> операций.

Итого, для n вершин получаем последовательную сложность <math>O(n log(n)+nm+m^2log(m))</math>.

== Информационный граф ==
[[File:СК.png]]

== Ресурс параллелизма алгоритма ==

Первый этап работы алгоритма можно распределить между <math>n</math> процессами. На вход каждому процессу подается своя вершина, далее происходит процедура поиска <math>k</math> ближайших соседей. Параллельная сложность составляет <math>O(n)</math>.

Второй и третий этапы можно распараллелить частично.

Второй этап распараллеливается путем подачи на вход свободному процессу очередного подграфа для разделения. Число итераций оценивается в <math>O(n log(n))</math>.

Третий этап делится на расчет показателей схожести и соединение подграфов в кластеры. Процесс расчета показателей можно распараллелить, подавая каждому процессу на вход пару подграфов. Сложность этого процесса оценивается как <math>m log(m)</math>. Соединение подграфов в кластеры выполняется последовательно, сложность процесса составляет <math>m^2 log(m)</math>

Таким образом получаем общую параллельную сложность алгоритма: <math>O(n+ n log(n) + m^2 log (m) + m log(m))</math>

== Входные и выходные данные алгоритма ==
'''Входные данные'''

1. Симметрическая матрица <math>A</math> расстояний между элементами данных размера <math>n\times n</math> с нулями на главной диагонали (<math>a_{ii}= 0, i = 1, \ldots, N</math>).

2. <math>k</math> - количество ближайших соседей для вершин (рекомендуемое значение <math>k</math> от 5 до 20 в зависимости от количества анализируемых объектов).

3. <math>l</math> - наименьшее число вершин, которое может содержать наибольший подкластер на 2-м этапе . Величина этого параметра варьируется от 1 до 5 % от общего числа объектов.

'''Объём входных данных'''

<math>\frac{n (n - 1)}{2}</math> (в силу симметричности и нулевой главной диагонали достаточно хранить только над/поддиагональные элементы).

'''Выходные данные'''

Вектор из <math>n</math> чисел <math>u_{1}, u_{2}, \ldots, u_{N}</math>, где <math>u_{i}</math> - целое число, соответствующее кластеру <math>i</math>-го объекта.

'''Объём выходных данных'''

<math>n</math>

== Свойства алгоритма ==
Соотношение последовательной и параллельной сложности на первом этапе является ''линейным'' для больших наборов данных и логарифмическим для n вершин. На втором этапе сложно оценить это соотношение - оно сильно зависит от параметров <math>k</math> и <math>l</math>. На третьем этапе соотношение равно <math>O(1)</math>;

Оценка ''вычислительной мощности'' выглядит следующим образом:

<math>O(1)</math> для 1-го этапа;

<math>O(\frac{nm}{n^2+m^2})</math> для 2-го этапа;

<math>O(\frac{m^2log(m)}{m^2+n})</math> для 3-го этапа;

Алгоритм является ''недетерминированным''. Хотя 1-й этап детерминирован, на 2-ом этапе могут быть найдены различные разбиения на подграфы, что повлияет и на итоговый результат работы алгоритма.

= Программная реализация алгоритма =
== Особенности реализации последовательного алгоритма ==
== Локальность данных и вычислений ==
== Возможные способы и особенности параллельной реализации алгоритма ==
== Масштабируемость алгоритма и его реализации ==

Масштабируемость исследовалась на основе работы, презентующей пробную версию параллельной реализации алгоритма для различного числа потоков<ref>http://research.ijcaonline.org/volume79/number8/pxc3891600.pdf</ref>.
График показывает, что эффективность и скорость работы алгоритма растут с увеличением объема входных данных. Однако, в упомянутой выше работе отмечается, что эффективность алгоритма падает с ростом количества потоков.

[[File:Масштабирование.png|700px|center]]

== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Последовательная реализация алгоритма доступна по ссылке <ref>http://read.pudn.com/downloads36/sourcecode/math/115779/chameleon/chameleon.c__.htm</ref>.

CHAMELEON можно реализовать с использованием графовых библиотек METIS <ref>http://glaros.dtc.umn.edu/gkhome/metis/metis/overview
</ref>, hMETIS <ref>http://glaros.dtc.umn.edu/gkhome/metis/hmetis/overview</ref> и RANN <ref>https://cran.r-project.org/web/packages/RANN/index.html</ref>.

Существует исследование, связанное с реализацией CHAMELEON посредством технологии OpenMP, оно было рассмотрено в пункте 2.4.

Параллельных реализаций алгоритма CHAMELEON не найдено.

= Литература =

Обсуждение участника:ЕкатеринаКозырева

2016-11-21T11:27:05Z

Algoman:

== Замечания к [[Участник:ЕкатеринаКозырева/Алгоритм_динамической_иерархической_кластеризации_CHAMELEON]] ==

1) отсутствует оценка высоты и ширины ЯПФ параллельного алгоритма во врезке в начале статьи

2) требуется какая-то подпись или ссылка на рисунок в п 1.1

3) подпись к рисунку 1.2 должны быть выполнена средствами разметки, а не на самой картинке

4) для оформления (псевдо) кода следует использовать тег <nowiki><source lang="..."></nowiki>

5) отсутствует оценка вычислительной мощности алгоритма в п 1.10

6) пункты 2.1 и 2.2 должны быть 2.4 и 2.7, согласно формату описания [[Структура_описания_свойств_алгоритмов]]

7) список литературы оформлен неправильно - см. как сделано в [[Разложение_Холецкого_(метод_квадратного_корня)]]

== Замечания к пункту 2.4 от 16.11.2016 ==

* отсутствует пункт 2.4

== Замечания к пункту 2.4 от 21.11.2016 ==

* для выполнения задания практикума иследование масштабируемости должно быть проведено самостоятельно

Участник:Ruslanlazovskiy/CHAMELEON

2016-11-21T11:21:13Z

Algoman:

{{Assignment|Algoman}}

{{algorithm
| name = CHAMELEON
| serial_complexity = <math>O(n*m + n*log{n} + m*log{m})</math>
| pf_height = <math>O(n)</math> - этап 1. <math>O(q)</math> - отдельная итерация этапа 3.
| pf_width = <math>O(n)</math> - этап 1. <math>O(q)</math> - отдельная итерация этапа 3.
| input_data = <math>n^2 / 2</math>
| output_data = <math>n</math>
}}

Авторы статьи:
[https://algowiki-project.org/ru/%D0%A3%D1%87%D0%B0%D1%81%D1%82%D0%BD%D0%B8%D0%BA:Ruslanlazovskiy|Лазовский Р. А.] ( разделы 1.1 - 1.4 , 1.7 , 1.8 ),
[https://algowiki-project.org/ru/%D0%A3%D1%87%D0%B0%D1%81%D1%82%D0%BD%D0%B8%D0%BA:%D0%9C%D1%83%D1%81%D1%82%D0%B0%D1%84%D0%B0%D0%B5%D0%B2_%D0%AD%D0%BB%D1%8C%D0%B2%D0%B8%D0%BD_%D0%AD%D0%BB%D1%8C%D0%BC%D0%B0%D0%BD%D0%BE%D0%B2%D0%B8%D1%87|Мустафаев Э. Э.] ( разделы 1.5 , 1.6 , 1.9 , 1.10 , 2.2 )

==Свойства и структура алгоритма==
===Общее описание алгоритма===
CHAMELEON – алгоритм динамической иерархической кластеризации графа, то есть процесса разбиения графа на несколько подграфов-кластеров таким образом, что данные внутри одного кластера имеют максимально схожи, а данные в разных кластерах — максимально различны. В классических алгоритмах кластеризации схожесть объектов определяется с помощью некоторой метрики ( простейший пример - евклидова метрика ). Не следует путать задачу кластеризации с задачей классификации - в последней характеристики объекта, необходимые для попадания в тот или иной класс, известны заранее, в рассматриваемой же задаче они становятся известны в процессе решения. Первоначально алгоритм был описан в статье<ref>CHAMELEON: A Hierarchical Clustering Algorithm Using Dynamic Modeling. George Karypis, Eui-Hong Han, Vipin Kumar. IEEE Computer 32(8): 68-75, 1999</ref>.

Алгоритм CHAMELEON работает в 3 этапа. На первом этапе исходное множество объектов организуется в граф по принципу k ближайших соседей. На втором этапе этого граф разбивается на достаточно малые подграфы-кластеры. На третьем этапе происходит агломеративная иерархическая кластеризация полученных подграфов в соответствии с одной из выбранных метрик ( возможные метрики будут подробно описаны далее ). Число получаемых в итоге кластеров в явном виде не задаётся.

===Математическое описание алгоритма===

Исходные данные: Первоначально исходными данными алгоритма являются <math>n</math> векторов длины <math>p</math>, каждый из которых соответствует одному объекту. На основании значений элементов этих векторов строится матрица смежности размера <math>n * n</math> ( возможно сокращение требуемого объема памяти до <math>(n*(n - 1))/ 2</math> в соответствии с выбранной метрикой. К исходным данным также относится набор параметров. Это <math>k</math> - количество ближайших соседей на первом этапе алгоритма, <math>q</math> - отношение количества вершин в наибольшем подграфе по отношению к общему числу объектов на втором этапе алгоритма, а также параметры <math>T_{RI}, T_{RI}</math> - пороговые значения, после которых прекращается агломеративная кластеризация на третьем этапе. Следует особо отметить, что число получаемых в итоге кластеров заранее не известно, хотя на него и можно повлиять изменением значений перечисленных параметров.

Первый этап алгоритма: На первом этапе на основании матрицы смежности строится граф <math>G = (V, E)</math> <math>k</math> ближайших соседей, где <math>V</math> - множество вершин графа ( т.е. объекты ), а <math>E</math> - множество ребер графа ( т.е. построенные связи между ближайшими соседями ). Указанный граф не обязательно является связным.

Второй этап алгоритма: Граф <math>G = (V, E)</math> итеративно разбивается на множество подграфов <math>G_{i} = (V_{i}, E_{i}), i = 1 .. m</math>, где <math> \cup V_{i} = V, i = 1 .. m</math>. Параметр <math>m</math> явно не задаётся, выполнение этого этапа алгоритма прекращается по выполнении описанных далее условий. На каждой итерации выбирается <math>G_{b}</math> с числом вершин, наибольшим среди всех подграфов, имеющихся на данной итерации. Этот граф разбивается на 2 подграфа <math>G_{bi}</math> и <math>G_{bj}</math> таких, что 1) <math>min(V_{bi},V_{bj}) >= 0.25 * V_{b}</math> ( имеется ввиду количество вершин ) и 2) <math>\sum{E_{kl}}, E_{kl} = (v_{k}, v_{l}), v_{k} \in V_{bi} , v_{l} \in V_{bj} </math> минимальна среди всех разбиений, удовлетворяющих 1). Итеративный процесс прекращается, когда <math>\sum{v_{b}} <= q * \sum{v} , v_{b} \in V_{b} , e \in E</math> ( имеется ввиду количество вершин ). Здесь <math>q</math> - задаваемый параметр, на практике он варьируется от <math>0.01</math> до <math>0.05</math>. Полученные подграфы называются малыми кластерами.

Третий этап алгоритма: Множество кластеров <math>G_{i} = (V_{i}, E_{i}), i = 1 .. m</math> итеративно преобразуется в множество кластеров <math>G_{j} = (V_{j}, E_{j}), j = 1 .. l</math>, <math>l <= m</math>. Для этого вводятся следующие понятия:

<math>EC_{(C_{i},C_{j})}</math> - абсолютная взаимная связность пары кластеров <math>C_{i}, C{j}</math>. Это суть сумма весов ребер, соединяющих вершины, принадлежащие <math>C{i}</math> c вершинами из <math>C{j}</math>. <math>EC_{(C_{i},C_{i})}</math> вычисляется как сумма ребер, входящих в разделитель, разбивающий <math>C{i}</math> на два равных подграфа. 
<math>S_{EC_{(C_{i},C_{j})}}</math> - абсолютное взаимное сходство пары кластеров <math>C_{i}, C{j}</math>. Это суть среднее сходство между соединенными вершинами, принадлежащими <math>C{i}</math> и <math>C{j}</math> соответственно. Соединения обусловлены разбиением общего графа, полученного на первом этапе алгоритма. 
<math>RI_{(C_{i},C_{j})} = \frac{2*|EC_{(C_{i},C_{j})}|}{|EC_{C_{i}}|+|EC_{C_{j}}|}</math> - относительная взаимная связность пары кластеров <math>C_{i}, C{j}</math> 
<math> RC_{(C_{i},C_{j})}= \frac{S_{EC_{(C_{i},C_{j})}}}{\frac{|C_{i}|}{|C_{i}+C_{j}|}*S_{EC_{(C_{i})}}+\frac{|C_{i}|}{|C_{i}+C_{j}|}*S_{EC_{(C_{j})}}}</math> - относительное взаимное сходство пары кластеров <math>C_{i}, C{j}</math> 

На основании этих показателей осуществляется агломеративная иерерхическая кластеризация. Существует две стратегии анализа показателей сходства. В первом случае для каждой пары кластеров <math>C{i}, C{j}</math> проверяется истинность выражений <math>RI_{(C_{i},C_{j})} >= T_{RI}</math> и <math>RC_{(C_{i},C_{j})} >= T_{RC}</math>, где <math>T_{RI}, T_{RI}</math> - заранее заданные пороговые значения. Если для некоторого <math>C_{i}</math> таких <math>C_{j}</math> несколько, то конкретная пара определяется по максимуму значения <math>EC_{(C_{i},C_{j})}</math>. Во втором случае выбираются пары кластеров, максимизирующие функцию вида <math>RI_{(C_{i},C_{j})}*RC_{(C_{i},C_{j})}^\alpha</math>. Здесь <math>\alpha</math> - заданный пользователем параметр. В обоих случаях процесс останавливается либо когда на очередной итерации не находится подходящих пар кластеров, либо когда остаётся только один кластер.

Вычисляемые данные: В процессе агломеративной кластеризации для всех объектов, т.е. всех вершин всех кластеров указывается индекс <math>j</math> кластера, к которому они принадлежат. После завершения алгоритма возможно перенумеровать кластеры. В любом случае на выходе будет иметься <math>n</math> значений, так как число объектов в процессе работы алгоритма не изменялось.

===Вычислительное ядро алгоритма===
В алгоритме 3 основных вычислительных ядра, по одному на каждый этап алгоритма.

На первом этапе алгоритма основная вычислительная нагрузка приходится на анализ матрицы смежности, необходимого для построения первоначального графа <math>G = (V, E)</math>, так как для каждого объекта необходимо перебрать всех его соседей и выделить <math>k</math> ближайших по заданной метрике.

На втором этапе наибольшее время занимает поиск подходящего разбиения очередного подграфа. В элементарном варианте этой процедуры необходимо перебрать все комбинации вершин в этом подграфе, удовлетворяющие условию 1) из математического описания алгоритма, и для каждой из них подсчитать значение, используемое в 2).

На третьем этапе алгоритма вычислительное ядро полностью совпадает с самим этапом, то есть итерационным процессов агломеративной иерархической кластеризации, включающем в себя подсчёт выбранной метрики для каждой пары кластеров, имеющихся на очередной итерации.

===Макроструктура алгоритма===
Как уже понятно из предыдущих разделов описания, алгоритм CHAMELEON выполняется в 3 этапа, последовательных относительно друг друга. Каждый этап, строго говоря, соответствует отдельному алгоритму. В рамках этого описания макрооперациями будут считаться процедуры разбиения наибольшего подграфа на каждой итерации второго этапа алгоритма, а также процедура вычисления метрики для принятия решения об объединении кластеров на каждой итерации третьего этапа.

===Схема реализации последовательного алгоритма===

Схема представлена в виде C++-подобного псевдокода, макрооперации в алгоритме выделены в соответствии с предыдущим разделом описания.

<source lang="C++">
// First stage.
int k // Number of neighbors.
float v[n][p] // Initial vectors.
float M[n][n] // Adjacency matrix.
for (int i = 0; i < n; ++i) {
for (int l = 0; l < n; ++l) {
M[i][l] = Compute_metric(v[i],v[l]);
}
}
Graph max_graph // Structure/class that represents a graph.
Neighbor_list list // Here neighbors are initially stored.
max_graph.add_vertices // Vertices ~ initial vectors.
for (int i = 0; i < n; ++i) {
for (int l = i + 1; i < n; ++i) { // "Smart" version - we do not repeat same vertex combinations.
if (neighbor_number < k) {
add_neighbor(v[i],v[l]) // Just add.
}else{
substitute_neighbor(v[i],v[l]) // Check whether a new element is closer than some of the oldies.
}
}
max_graph.add_neighbors // Looks at neighbor lists of current vector and adds them
}
</source>

<source lang="C++">
// Second stage.
float percent // Determines when to stop splitting graphs.
Graph graphs[n] // GRAPHS WILL MOST LIKELY TAKE LESS SPACE, IT'S JUST THE UPPER LIMIT.
max_graph = find_max_graph() // Biggest graph by number of vertices available.
while (graph_size(max_graph) > n * percent) {
Split_graph(max_graph); // Split the graph - a macro operation that represents the second phase.
}
</source>

<source lang="C++">
// Third stage.
Graph graphs[m] // That's how many graphs we got. m <= n.
bool pairs_exist // Check if the're pairs of clusters to unite.
while (num_graphs > 1 && pairs_exist){
pairs_exist = false // So we don't repeat if it fails.
for (int i = 0; i < m; ++i) {
for (int l = i + 1; l < m; ++l) { // Also a "Smart" version.
check_pair(pairs_exist, graphs[i], graphs[l]); // Check whether graphs are similar enough by some metrics.
if (pairs_exist) { Unite_graphs(graphs[i], graphs[l]) }; // Pairs_exist is set to true if something's found.
}
}
}
</source>

===Последовательная сложность алгоритма===

Общая временная сложность последовательного варианта алгоритма CHAMELEON определяется как <math>O(nm + nlog{n} + mlog{m})</math>, где <math>n</math> - число исходных объектов, <math>m</math> - число малых кластеров, полученных после первого этапа работы. В случае "предельного" разбиения <math>m = n</math> эта оценка превращается в <math>O(n^2)</math>. В любом случае эта оценка не учитывает необходимости построения матрицы смежности по исходному набору векторов (авторы оригинальной статьи в своих исследованиях подразумевают, что матрица смежности уже построена), что означает дополнительные <math>O(n^2)</math> операций. Тогда оценка будет составлять <math>O(n^2 + nm + nlog{n} + mlog{m})</math> операций или <math>O(n^2)</math> в случае "предельного" разбиения.
Следует также обратить внимание, что это оценка по числу не сложений и умножений, а достаточно крупных операций. Например, вычисление метрики между двумя векторами рассматривается как одна операция, а она включает в себя <math>n</math> умножений и <math>2n</math> сложений ( для вычисления квадратичной нормы разности векторов).

===Информационный граф===

Информационный граф дан в соответствии с макроструктурой алгоритма. Следует отметить, что имеются успешные попытки распараллелить 2 и 3 этапы алгоритма CHAMELEON ( см. раздел "Существующие реализации" ). Однако они включают в себя модификацию исходного алгоритма. Также возможно распараллеливание выборки пар кластеров и подсчёта их метрик внутри каждой из вершин stage_3_iter. Структура информационного графа внутри этих итераций аналогична структуре информационного графа первого этапа алгоритма.

[[File:CHAMELEON ruslanlazovskiy.png]]

===Ресурс параллелизма алгоритма===

Параллельную сложность алгоритма CHAMELEON следует оценивать отдельно для каждого этапа.
На первом этапе алгоритм поиска <math>k</math> ближайших соседей может быть выполнен за <math>n - 1</math> вычислений значения метрики между двумя векторами.
На втором этапе итерации алгоритма выполняются строго последовательно, а распараллеливание алгоритма внутри итерации не относится к теме статьи.
На третьем этапе итерации также выполняются последовательно, однако возможно распараллеливание обработки пар кластеров внутри итерации. Каждая итерация может быть выполнена за <math>q - 1</math> вычислений значения метрики между двумя кластерами, где q - количество кластеров на этой итерации.

===Входные и выходные данные алгоритма===

Входные данные:

<math>O</math> - набор из <math>n</math> векторов длины <math>p</math>. 
<math>k</math> - число, определяющиее количество ближайших соседей, по которым строится первоначальный граф. 

Выходные данные:

<math>B</math> - вектор длины <math>n</math>, значение <math>i</math>-го элемента указывает на принадлежность соответствующего вектора одному из кластеров.

===Свойства алгоритма===

Соотношение последовательной и параллельной сложности: Различные этапы алгоритма строго последовательны относительно друг друга. На первом этапе отношение последовательной сложности алгоритма к параллельной есть <math>n/2</math>. На втором и третьем этапах различные итерации последовательны относительно друг друга. Однако внутри итераций допускается некоторый параллелизм. Например, для итераций третьего этапа в наилучшем случае отношение сложности последовательной реализации к параллельной есть <math>q/2</math>, где <math>q</math> - число кластеров на конкретной итерации.

Вычислительная мощность: графовые алгоритмы, вообще говоря, обладают низкой вычислительной мощностью. В случае CHAMELEON вычислительная мощность первого этапа равна <math>O(1)</math>. Для второго и третьего этапов оценка вычислительной мощности по сложениям и умножениям затруднительна, однако в терминах макроопераций можно дать грубую оценку. Вычислительная мощность каждой итерации второго этапа - <math>1 / \sum C_n^k</math>, где <math>n</math> - число вершин в выбранном подграфе, а <math>k</math> варьируется от <math>0.25 * n</math> до <math>0.5 * n</math>. Вычислительная мощность каждой итерации третьего этапа в этих терминах - <math>O(1)</math>.

Детерминированность: Важной особенностью описываемого алгоритма является его недетерминированность. Условия завершения как 2-го, так и 3-го этапа позволяют обозначить CHAMELEON как итерационный алгоритм с выходом по точности. При этом детерминированность 2-го этапа алгоритма можно обеспечить указанием вырожденных условий кластеризации ( такая кластеризация, очевидно, не будет иметь практического смысла ), в то время как 2-ый этап является недетерминированным всегда.

==Программная реализация алгоритма==
===Особенности реализации последовательного алгоритма===
===Локальность данных и вычислений===
===Возможные способы и особенности параллельной реализации алгоритма===
===Масштабируемость алгоритма и его реализации===

Как можно увидеть из раздела "существующие реализации", параллельной реализации алгоритма CHAMELEON на система с распределенной памятью найдено не было. Однако в <ref name = "exp">Parallel Algorithm for the Chameleon Clustering Algorithm using Dynamic Modeling. Rajnish Dashora, Harsh Bajaj, Akshat Dube, Geetha Mary .A. VIT University,Vellore. International Journal of Computer Applications (0975 – 8887) Volume 79 – No8, October 2013 </ref>. приводится экспериментальный вариант параллельной реализации посредством OpenMP для систем с общей памятью, включающий в себя значительную модификацию исходного алгоритма, но не приводится рабочая реализация.

В силу вышескасновного основное внимание будет уделено исследованию масштабируемости алгоритма по размеру задачи, в пределах одного узла. Далее приводятся графики производительности в Гфлопс для различных размеров задачи. Эффективность работы алгоритма убывает на всей рассматриваемой области. Темпы убывания эффективности снижаются с ростом размера задачи.

Для исследования такой масштабируемости вширь использовалась референсная последовательная реализация алгоритма ( м. раздел "Существующие реализации" ). Соответствующая программа запускалась на системе BG/P на одном вычислительном узле. Характеристики вычислительного узла, а также микропроцессорного ядра - элемента такого узла, приводятся в <ref>http://hpc.cmc.msu.ru/bgp</ref> Таким образом, удостоверенными экспериментальными данными являются только значения, полученные для случая 1 процесса. Значения для случаев 2 и 4 процессов являются ОЦЕНОЧНЫМИ и выводятся из результатов работы модифицированной версии алгоритма, исследуемой в <ref name = "exp">Parallel Algorithm for the Chameleon Clustering Algorithm using Dynamic Modeling. Rajnish Dashora, Harsh Bajaj, Akshat Dube, Geetha Mary .A. VIT University,Vellore. International Journal of Computer Applications (0975 – 8887) Volume 79 – No8, October 2013 </ref>. К сожалению, указанной реализации авторы не предоставляют.

[[File:CHAMELEON performance.png|800px]]

===Динамические характеристики и эффективность реализации алгоритма===
===Выводы для классов архитектур===
===Существующие реализации алгоритма===
С копией референсной реализации иерархической кластеризации, взятой с данного ресурса [http://us.codeforge.com/article/192925 Sequental], в случае неработоспособности последнего, можно ознакомиться здесь [http://pastebin.com/PhC4X0Cy Copy] 
Последовательная реализация алгоритма CHAMELEON использовалась в статье <ref>Clustering Of Web Usage Data Using
Chameleon Algorithm, T.Vijaya Kumar, Dr. H.S.Guruprasad, International Journal of Innovative Research in Computer
and Communication Engineering, Vol. 2, Issue 6, June 2014</ref>
Теоретически возможна реализация алгоритма CHAMELEON с использованием графовых библиотек, например [http://glaros.dtc.umn.edu/gkhome/metis/metis/overview METIS ], [http://glaros.dtc.umn.edu/gkhome/metis/hmetis/overview hMETIS] и [https://cran.r-project.org/web/packages/RANN/index.html RANN]. 
Параллельных реализаций алгоритма CHAMELEON в графовых библиотеках мною найдено не было. Однако существует исследование, связанное с реализацией CHAMELEON посредством технологии OpenMP, с которым можно ознакомиться здесь [http://research.ijcaonline.org/volume79/number8/pxc3891600.pdf параллельная реализация].

==Литература==

<references \>

Краткий обзор алгоритма [http://studopedia.ru/7_41934_algoritm-dinamicheskoy-ierarhicheskoy-klasterizatsii-CHAMELEON.html|] 
Первоначальная статья от авторов алгоритма [http://www-users.cs.umn.edu/~han/dmclass/chameleon.pdf|] 
Исследования возможной параллелизации алгоритма[http://research.ijcaonline.org/volume79/number8/pxc3891600.pdf|]

Участник:Артем Таран/Графо-ориентированный алгоритм кластеризации CHAMELEON

2016-11-18T09:07:42Z

Algoman:

{{Assignment|Algoman}}
{{algorithm
| name = Графо-ориентированный алгоритм кластеризации CHAMELEON
| serial_complexity = <math>O(n^2+nm+m^2log(m))</math>
| pf_height = <math>O(n + log(n) + mlog(m) + m^2log(m))</math>
| pf_width = <math>O(n)</math>
| input_data = <math>\frac{n (n - 1)}{2}</math>
| output_data = <math>n</math>
}}

Статью подготовили: [[Участник:Артем_Таран|Артём Таран Иванович]] (разделы 1.1 - 1.10, 2.7), [[Участник:ShimchikN|Шимчик Никита Владимирович]] (разделы 1.1 - 1.10, 2.7).
== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===

Кластеризация — многомерная статистическая процедура, выполняющая сбор данных, содержащих информацию о выборке объектов, и затем упорядочивающая объекты в сравнительно однородные группы (кластеры) с минимизацией межкластерного сходства и максимизацией внутрикластерного сходства.

Графо-ориентированный алгоритм кластеризации CHAMELEON<ref name="rt">http://www-users.cs.umn.edu/~han/dmclass/chameleon.pdf</ref> - алгоритм, который измеряет сходство двух кластеров на основе
динамической модели. В процессе кластеризации два кластера объединяются, только если показатели взаимосвязанности и близости между двумя кластерами являются высокими по отношению к показателям внутренней взаимосвязанности кластеров и близости элементов внутри этих кластеров. Процесс слияния с использованием динамической модели, использующийся в данном алгоритме облегчает открытие
природных и однородных кластеров. Методология динамического моделирования кластеров, использующаяся в CHAMELEON,
применима ко всем типам данных, для которых может быть построена матрица подобия.

Следует отметить, что конечное число кластеров не задаётся явным образом и зависит как от выбора параметров алгоритма, так и от внутренней структуры входных данных.

Алгоритм кластеризации CHAMELEON включает в себя три этапа:

1) Построение графа, путём добавления рёбер по принципу k ближайших соседей.

2) Выделение множества сравнительно малых связных подграфов.

3) Формирование набора кластеров, на основе множества подграфов, полученных на предыдущем этапе.

[[Файл:Графы k ближайших соседей.jpg|1000px|thumb|center|Графы k ближайших соседей: 1) объекты в пространстве, 2) граф по принципу 1-го ближайшего соседа, 3) граф по принципу 2-го ближайшего соседа, 4) граф по принципу 3-х ближайших соседей<ref name="rt">http://www-users.cs.umn.edu/~han/dmclass/chameleon.pdf</ref>]]

=== Математическое описание алгоритма ===
==== Данные ====
* '''Исходные данные''': множество из <math>n</math> точек <math>V = \{v_{i}\}</math> в метрическом пространстве, которое может быть задано в виде треугольной матрицы расстояний <math>A</math> размера <math>n\times n</math>; натуральное число <math>k</math>, используемое в качестве параметра алгоритма поиска k ближайших соседей.

* '''Промежуточный результат после первого этапа''': граф <math>G = (V, E)</math>, полученный путём соединения каждой точки с её <math>k</math> ближайшими соседями.

* '''Промежуточный результат после второго этапа''': разбиение множества <math>V</math> на набор <math>K = \{K_{i}\}</math> попарно непересекающихся связных подмножеств, из которого образуется взвешенный граф <math>G_{2} = (K, E_{2})</math>.

* '''Промежуточный результат после третьего этапа''': итоговое разбиение множества вершин графа <math>G_{2}</math> на набор кластеров <math>C = \{C_{i}\}</math>.

* '''Вычисляемые данные''': n-мерный вектор <math>v</math> (элементы <math>v_{i}</math>), показывающий отображение исходного множества точек на набор кластеров <math>C</math>.

==== Определения ====

* ''Абсолютная взаимная связность между парой кластеров <math>C_{i}</math> и <math>C_{j}</math>'' определяется как сумма весов ребер, соединяющих вершины, принадлежащие <math>C_{i}</math> с вершинами из <math>C_{j}</math>. Эти ребра, фактически, входят в разделитель ребер графа, состоящего из кластеров <math>C_{i}</math> и <math>C_{j}</math>, и разбивающим его на подграфы <math>C_{i}</math> и <math>C_{j}</math>. Обозначается эта величина как
<math>EC_{(C_{i},C_{j})}</math>. Внутреннюю связность <math>EC_{C_{i}}</math> кластера <math>C_{i}</math> можно вычислить как сумму ребер, входящих в разделитель ребер, разбивающий <math>C_{i}</math> на два совершенно равных подграфа.

* ''Относительная взаимная <math>RI_{(C_{i},C_{j})}</math> связность пары кластеров <math>C_{i}</math> и <math>C_{j}</math>'' определяется формулой:

<math>RI_{(C_{i},C_{j})} = \frac{2*|EC_{(C_{i},C_{j})}|}{|EC_{C_{i}}|+|EC_{C_{j}}|}</math>

Учитывая значения относительной взаимной связности, можно добиться получения кластеров разного размера, формы и плотности, то есть общего внутреннего сходства.

* ''Абсолютное взаимное сходство между парой кластеров <math>C_{i}</math> и <math>C_{j}</math>'' подсчитывается как среднее сходство между соединенными вершинами, принадлежащими <math>C_{i}</math> и <math>C_{j}</math> соответственно. Эти соединения обусловлены предыдущим разбиением общего графа, полученного на матрице сходства.

* ''Относительное взаимное сходство <math>RC_{(C_{i},C_{j})}</math> между парой кластеров <math>C_{i}</math> и <math>C_{j}</math>'' определяется как абсолютное сходство между этой парой кластеров, нормализованное с учетом их внутреннего сходства и вычисляется по формуле:

<math> RC_{(C_{i},C_{j})}= \frac{S_{EC_{(C_{i},C_{j})}}}{\frac{|C_{i}|}{|C_{i}+C_{j}|}*S_{EC_{(C_{i})}}+\frac{|C_{i}|}{|C_{i}+C_{j}|}*S_{EC_{(C_{j})}}}</math>,

где <math>S_{EC_{(C_{i})}}</math> и <math>S_{EC_{(C_{i})}}</math> - средние веса ребер (значения сходства), принадлежащих разделителю ребер кластеров <math>C_{i}</math> и <math>C_{j}</math> соответственно,
и <math>S_{EC_{(C_{i},C_{j})}}</math> - средний вес ребер, соединяющих вершины <math>C_{i}</math> с вершинами <math>C_{j}</math>, причем ребра принадлежат разделителю ребер <math>EC_{(C_{i})}</math>, определенному ранее.

Далее, алгоритм применяет агломеративную иерархическую кластеризацию с использованием вышеозначенных показателей. Причем существует две стратегии их учета. Первая подразумевает наличие некоторых пороговых значений <math>T_{RI}</math> и <math>T_{RC}</math>. В соответствии с этой стратегией, алгоритм для каждого кластера <math>C_{i}</math> проверяет, отвечают ли смежные (наиболее близкие) ему кластеры условиям:

*<math>RI_{(C_{i},C_{j})} \geqslant T_{RI}</math>

*<math>RC_{(C_{i},C_{j})} \geqslant T_{RC}</math>

Если более одного смежного кластера отвечает этим условиям, то алгоритм выбирает для объединения наиболее связный кластер (граф), то есть такой кластер <math>C_{j}</math>, с которым у кластера <math>C_{i}</math> получается наибольшая абсолютная взаимная связность. По завершению прохода по всем кластерам, созданные таким образом пары объединяются. Параметры <math>T_{RI}</math> и <math>T_{RC}</math> могут использоваться для изменения характеристик получаемых кластеров.

Вторая стратегия заключается в использовании специальной функции, объединяющей понятия относительной взаимной связности и относительного взаимного сходства. На каждом шаге выбираются те кластеры для объединения, которые максимизируют эту функцию:

<math>RI_{(C_{i},C_{j})}*RC_{(C_{i},C_{j})}^\alpha</math>,

где <math>\alpha</math> выбирается пользователем. Если <math>\alpha > 1 </math>, то алгоритм придает большее значение относительному взаимному сходству, а если <math>\alpha < 1 </math>, то большее значение имеет относительная взаимная связность. Разумеется, данный подход позволяет получить полную дендрограмму кластерного анализа<ref name="rty">http://studopedia.ru/7_41934_algoritm-dinamicheskoy-ierarhicheskoy-klasterizatsii-CHAMELEON.html</ref>.

=== Вычислительное ядро алгоритма ===

На первом этапе работы алгоритма вычислительным ядром можно считать процесс нахождения k ближайших соседей для каждой отдельной вершины.

На втором этапе работы алгоритма вычислительным ядром является поиск разбиения графа на два подграфа с минимизацией разделителя рёбер графа.

На третьем этапе работы алгоритма вычислительным ядром является расчёт <math>EC_{(C_{i},C_{j})}</math>, <math>RC_{(C_{i},C_{j})}</math> и <math>RI_{(C_{i},C_{j})}</math> для пары смежных кластеров, а также их слияние.

=== Макроструктура алгоритма ===

Алгоритм CHAMELEON выполняется в 3 этапа, последовательных относительно друг друга. Каждый этап соответствует отдельному алгоритму.

* Макрооперацией на первом этапе является процедура выделения k ближайших соседей.

* Макрооперацией на втором этапе является процедура разбиения наибольшего подграфа на каждой итерации.

* Макрооперациями на третьем этапе являются процедуры вычисления метрики для принятия решения об объединении кластеров и объединение кластеров на каждой итерации.

=== Схема реализации последовательного алгоритма ===

* Первый этап (псевдокод):
integer n; // Количество точек.
integer k; // Параметр k
integer A[n][n]; // Верхняя треугольная матрица расстояний между точками.

integer E[n][n]; // Верхняя треугольная матрица рёбер графа G - изначально инициализирована нулями.
foreach (integer i in (1,n-1) ) {
integer Neighbours[k]; // матрица, используемая хранения ближайших соседей
integer countN = 0;

foreach (integer j in (i+1, n) ) {
// Заполняем матрицу Neighbours, добавляя новые элементы и увеличивая счётчик countN.
// Когда countN станет равен k, новые элементы будут вставляться на место старых, либо отбрасываться.
}

foreach (integer j in (0, countN) ) {
E[min(i,j), max(i,j)] = 1;
}
}
return E;

* Второй этап:
[[File:Диаграмма_шаг_2.png]]

* Третий этап:
[[File:Chameleon_stage_3.png|611px]]

=== Последовательная сложность алгоритма ===
1) Построение графа на основе метода k ближайших соседей в худшем случае требует <math>O(n^2)</math> операций;

2) Для выделения множества сравнительно малых связных подграфов требуется <math>nm</math> операций;

3) Формирование набора кластеров, на основе множества подграфов, полученных на предыдущем этапе, требует <math>m^2log(m)</math> операций.

Итого, получаем последовательную сложность <math>O(n^2+nm+m^2log(m))</math>.

=== Информационный граф ===

[[File:Chameleon_inforgraph.png|811px]]

=== Ресурс параллелизма алгоритма ===

Первый этап работы алгоритма можно распределить между <math>n</math> процессами: в этом случае каждому процессу назначается своя точка и происходит поиск <math>k</math> ближайших соседей. Таким образом, его параллельная сложность составляет <math>O(n)</math>.

На втором этапе количество задействованных процессов может варьироваться в зависимости от входных данных. В худшем случае число итераций можно оценить как <math>O(log(n))</math>.

На третьем этапе можно распараллелить процесс расчёта метрик сходства между кластерами, однако итоговое слияние всё равно должно выполняться последовательно.
Поскольку процесс сравнения кластеров возможно распараллелить, сложность 3-го этапа составляет <math>mlog(m) + m^2log(m)</math>.

Таким образом, суммарная параллельная сложность оказывается равна <math>O(n + log(n) + mlog(m) + m^2log(m))</math>.

=== Входные и выходные данные алгоритма ===

* Входные данные:

1) Треугольная матрица <math>A</math> размера <math>n\times n</math> (где n — количество объектов), в которой элементу <math>a_{ij}</math> соответствует расстояние между i-м и j-м объектами.

2) Количество ближайших соседей <math>k</math> для вершин (рекомендуемое значение <math>k</math> от 5 до 20 в зависимости от количества анализируемых объектов).

3) Наименьшее число вершин, которое может содержать наибольший подграф на 2-м этапе <math>l</math>. Величина этого параметра варьируется от 1 до 5 % от общего числа объектов.

* Объём входных данных: <math>\frac{n (n - 1)}{2}</math>

* Выходные данные: n-мерный вектор <math>v</math>, в котором элементу <math>v_{i}</math> соответствует номер кластера, присвоенный i-му объекту

* Объём выходных данных: <math>n</math>

=== Свойства алгоритма ===

Первый этап алгоритма обладает хорошим ресурсом параллелизма: параллельная сложность его выполнения составляет <math>O(n)</math>, что намного лучше последовательной оценки <math>O(n^2)</math>.

У второго и третьего этапов алгоритма сложно полностью оценить ресурсы параллелизма. Но оба этапа возможно частично распараллелить.

'''Вычислительную мощность''' для разных этапов алгоритма можно оценить как:

1 этап: <math>O(1)</math>

2 этап: <math>O(\frac{nm}{n^2+m^2})</math>

3 этап: <math>O(\frac{m^2log(m)}{m^2+n})</math>

Детерминированность: Важной особенностью данного алгоритма является его недетерминированность. Несмотря на то, что 1-й этап детерминирован, алгоритм в целом является недетерминированным, так как на 2-ом этапе могут быть найдены различные разбиения на подграфы, а это повлияет и на итоговый результат работы алгоритма.

== Программная реализация алгоритма ==

=== Особенности реализации последовательного алгоритма ===

=== Локальность данных и вычислений ===

=== Возможные способы и особенности параллельной реализации алгоритма ===

=== Масштабируемость алгоритма и его реализации ===

Проводилось исследование масштабируемости экспериментальной версии параллельной реализации алгоритма для малого числа потоков<ref name="tr">http://research.ijcaonline.org/volume79/number8/pxc3891600.pdf</ref>.

Его результаты отражены на графиках. Из графиков видно, что ускорение и эффективность алгоритма растут с увеличением объема данных.

Однако можно заметить, что с увеличением числа потоков эффективность алгоритма падает.

[[File:Plot cham.jpg|850px|center]]

[[File:Cham_speedup.png]] [[File:Cham_eff.png]]

=== Динамические характеристики и эффективность реализации алгоритма ===

=== Выводы для классов архитектур ===

=== Существующие реализации алгоритма ===

Существует несколько последовательных реализаций алгоритма. С одной из них можно ознакомиться по ссылке <ref name="tra">http://www.codeforge.com/article/192925</ref>.

Возможна реализация алгоритма CHAMELEON с использованием графовых библиотек, как, например METIS <ref name="tru">http://glaros.dtc.umn.edu/gkhome/metis/metis/overview</ref> , hMETIS <ref name="tri">http://glaros.dtc.umn.edu/gkhome/metis/hmetis/overview</ref> и RANN <ref name="tro">https://cran.r-project.org/web/packages/RANN/index.html</ref>.

Параллельных реализаций алгоритма CHAMELEON найдено не было. Однако существует исследование, связанное с реализацией CHAMELEON посредством технологии OpenMP, с которым можно ознакомиться здесь <ref name="tr">http://research.ijcaonline.org/volume79/number8/pxc3891600.pdf</ref>.

== Литература ==

<references \>

Участник:EasyBreezy/Стабилизированный метод бисопряженных градиентов (BiCGSTAB)

2016-11-18T08:47:22Z

Algoman:

Основные авторы описания: [[Участник:Novikov alexander|Александр Новиков (1.4, 1.6, 1.7, 2.4, 2.7, 3)]], [[Участник:EasyBreezy|Гаврилов Алексей (1.1 - 1.3, 1.5, 1.8, 1.9, 2.7, 3)]]

{{algorithm
| name = BiCGSTAB
| serial_complexity = <math> O(n^2) </math>, где <math> n </math> - размерность СЛАУ
| pf_height = <math> O(k*(6 \sqrt n + 4n + 5 \lceil \frac{n}{p} \rceil)) </math>
| pf_width = <math> 2 \sqrt n </math>
| input_data = матрица <math>A \in R^{N \times N}</math> ( <math>C^{N \times N}</math> ) и вектор правой части <math>b \in R^N</math> ( <math>C^N</math> )
| output_data = вектор решения системы <math>x \in R^N</math> ( <math>C^N</math> )
}}
== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===

:Стабилизированный метод бисопряженных градиентов, так же известный как BiCGSTAB (Biconjugate gradient stabilized method), был предложен голландским математиком Хенком ван дер Ворстом<ref>Henk A. vander Vorst, Iterative Krylov Methods for Large Linear Systems, Cambridge University Press 2003, 230p</ref> в 1992 году. Статья, в которой описывался метод, стала самым цитируемым научным трудом в области математики в 1990х годах.

:Метод появился, как ответ на задачу о построении способа решения систем линейных алгебраических уравнений произвольного вида. На момент появления BiCGSTAB уже существовали методы решения СЛАУ произвольного типа, в том числе и в комплексном пространстве, например метод бисопряженных градиентов. Однако существующие на тот момент методы либо обладали недостаточной скоростью сходимости, либо использовали в вычислениях тяжелые операции, такие как транспонирования матрицы, которые усложняли распараллеливание на многопроцессорных машинах.
:BiCGSTAB является итерационным методом решения систем линейных алгебраических уравнений. Мощь метода заключается в том, что его можно применять к матрицам общего вида, в том числе с комплексными коэффициентами. В процессе выполнения BiCGSTAB не использует для вычисления плохо распараллеливаемых операций, не допускает накопления погрешностей округления и нестабильного поведения невязки. Эти факторы выгодно отличают его от предшественников: метода бисопряженных градиентов и квадратичного метода сопряженных градиентов, из которого BiCGSTAB фактически и вытекает. К преимуществам так же можно добавить более высокую в общем случае скорость сходимости относительно ближайших конкурентов. Тем не менее, для некоторых видов СЛАУ BiCGSTAB может уступать более простым методам.<ref>Горбаченко В.И, Вычислительная линейная алгебра с примерами на MATLAB. — СПб.: БХВ-Петербург, 2011. — 320 с.: ил. — (Учебное пособие)</ref>

:Благодаря свойствам алгоритма область применения метода весьма широка. Фактически, он используется во всех задачах, где требуется решать СЛАУ, в том числе СЛАУ большой размерности, к которым сводится большое количество численных методов, применяемых при решении задач математического моделирования.

:BiCGSTAB относится к классу так называемых проекционных методов. Основная идея методов данного класса: искать итерационным способом наилучшее приближение решения в некотором подпространстве пространства <math>R^n</math>, и чем шире подпространство, в котором ищется приближение решения, тем ближе будет приближенное решение к точному на каждой итерации. В качестве такого подпространства используются пространства Крылова, порожденные матрицей системы и невязкой первого приближения: <math>K^m (A, r^0) = span(r^0, Ar^0, A^2r^0, ..., A^{m-1} r^0).</math><ref>Горбаченко В.И, Вычислительная линейная алгебра с примерами на MATLAB. — СПб.: БХВ-Петербург, 2011. — 320 с.: ил. — (Учебное пособие)</ref>

:Изложим основную идею любого проекционного метода, заложенную в том числе и в BiCGSTAB. Для простоты выкладок и рассуждений здесь и далее будем считать, что матрица системы и ее правая часть вещественны. Без ограничения общности все дальнейшие рассуждения могут быть перенесены и на комплексный случай. Итак, пусть решается система <math>Ax=b</math> с невырожденной матрицей <math>A \in R^{n \times n}</math> и ненулевым вектором <math>b \in R^n</math>. Имеются два подпространства <math>K_n</math> и <math>L_n</math>. Требуется найти вектор <math>x \in K_n</math>, который обеспечивает решение системы, оптимальное относительно подпространства L, то есть требуется выполнение условия Петрова-Галеркина: <math>(Ax,z)=(b,z), \forall z \in L_n</math>. В данном случае вектор x называется обобщенным решением системы.

:Условие Петрова-Галеркина можно записать и через определение невязки. Пусть <math>r = b - Ax</math> - невязка, тогда условие Петрова-Галеркина перепишется в виде: <math>(b - Ax, z)=(r, z),\forall z \in L_n</math>. Это равносильно тому, что вектор невязки ортогонален пространству <math>L_n</math>.

:Пусть для СЛАУ известно некоторое приближение <math>x^0</math> точного решения <math>x^*</math>. Данное приближение требуется уточнить поправкой <math> \delta: b - Ax^0 + \delta \perp L</math>. Невязка уточненного решения имеет вид: <math>r_{new} = b - Ax^0 + \delta = r^0- A\delta</math>. Условие Петрова-Галеркина тогда можно переписать так: <math>(r_{new}, z)= r^0 - (A\delta, z) = 0, \forall z \in L</math>

:Пусть <math> dim K = dim L = m, V = (v_1, ..., v_n) \in R^{n \times m}, W = (w_1, ... w_n) \in R^{n \times m}</math>, где V и W – матрицы, столбцы которых образуют базисы пространств K и L соответственно. Пусть так же <math> \delta = Vy, z = Wq</math>, где y – коэффициенты разложения вектора поправки по базису пространства K, а q – коэффициенты разложения вектора z в пространстве L. Тогда новое приближение решения можно записать в виде: <math>x^1 = x^0 + \delta= x^0 + Vy</math>. Из условия ортогональности Петрова-Галеркина получаем, что: <math>(r - AVy, Wq) = (W^Tr^0 - AVy, q) = 0</math>. Поскольку <math>q \neq 0</math>, то получаем СЛАУ для вектора y: <math>W^TAVy = W^Tr^0</math>. Если предположить, что матрица <math>W^TAVy</math> невырождена, то вектор y однозначно определяется и равен: <math>y = W^TAV^{-1}W^Tr^0</math>. Подставляя найденные коэффициенты разложения в выражение для первого приближения получаем: <math>x^1 = x^0 + \delta = x^0 + W^TAV^{-1}W^Tr^0y</math>

:Подведем итог. Общий порядок шагов любого проекционного метода следующий:
#Выбрать пару подпространств <math>K</math> и <math>L</math>
#Найти базис V пространства K и базис W пространства <math>L</math>;
#Вычислить невязку
#Найти <math>y = W^T AV^{-1} W^T r^0</math>
#Положить <math>x = x + Vy</math>
#Если не достигнут критерий остановки итерационного процесса, то повторить алгоритм, начиная с первого шага.

:Как будет показано далее, в BiCGSTAB не требуется вычислять матрицу <math>W^T AV^{-1}</math> в явном виде.

=== Математическое описание алгоритма ===
:Рассмотрим СЛАУ с вещественными коэффициентами:
<center><math>Ax = b, A \in R^{N \times N}, b \in R^N</math></center>
<center><math></math></center>
:В основу алгоритма ложиться идея проекционного метода и использование свойства A-бисопряженности системы векторов, а именно: векторы <math>p^1, p^2, ...</math> и <math>\overline p^1, \overline p^2, ...</math> бисопряжены, если <math>(Ap^i,p^j ) = 0,</math> при <math>i \neq j</math>. Фактически, данное условие эквивалентно биортогональности относительно энергетического скалярного произведения.

:Общая концепция проекционных методов предписывает нам выбрать два подпространства. В нашем случае подпространства мы выберем два подпространства, задаваемые матрицей системы А, вектором невязки на нулевой итерации <math>r^0</math> и вектором <math>\overline r^0</math>. который выбирается из условия <math>(r^0, \overline r^0) \neq 0</math>:

<center><math>K = K^k(A, r^0), L = K^k(A, \overline r^0)</math></center>

:Метод основан на построении биортогонального базиса <math>p^0, p^1, ... p^k .. </math> пространства <math>K^k (A, r^0) </math> и вычислении поправки такой, что новое приближение на очередной итерации было бы ортогонально второму подпространству Крылова. Базисные вектора строятся до тех пор, пока не будет достигнут критерий остановки итерационного процесса, а каждое последующее приближение формируется, как сумма приближения на предыдущей итерации и найденной поправки. Критерием останова итерационного процесса является достижения невязкой значения, которое меньше некоторого наперед заданного числа <math>\epsilon</math>.

:Основной итерационный процесс задается формулами:
<center><math>x^{k + 1} = x^k + \alpha_k p_k + \omega_k s_k</math></center>
<center><math>p^{k + 1} = r^{k + 1} + \beta_k p_k - \omega_k Ap_k</math></center>
:где:
#<math>x^{k + 1}</math> - приближение на следующей итерации
#<math>x^k</math> - приближение на предыдущей итерации
#<math>p_k</math> - базисный вектор подпространства Крылова, порожденного матрице СЛАУ и невязкой
#<math>\alpha_k, \omega_k</math> - вспомогательные скаляры, определяемые для каждого шага итерации
#<math>s_k</math> - вспомогательный вектор
#<math>p^{k + 1}</math> - <math>k + 1</math>-ый базисный вектор
#<math>r^{k + 1}</math> - невязка <math>k + 1</math>-ой итерации
#<math>\beta_k</math> - вспомогательный коэффициент

:Вспомогательный вектор выражается следующим образом:
*<math>s_k = r^k - \alpha_k Ap_k</math>

:Вспомогательные коэффициенты вычисляются по формулам:
*<math>\alpha_k = \frac{(r^k, \overline r^0)}{(Ap_k, \overline r^0)}</math>
*<math>\omega_k = \frac{(As_k, s_k)}{(As_k, As_k)}</math>
*<math>\beta_k = \frac{(r^{k + 1}, \overline r^0)}{(r^k, \overline r^0}</math>

:Подведем итог и запишем итерационный процесс
:Подготовительный этап:
#Выбирается некоторое начальное приближение <math>x^0</math>
#По выбранному приближению находится невязка <math>r^0 = b - Ax^0</math>
#Из условия <math>(r^0, \overline r^0) \neq 0</math> выбирается вектор <math>\overline r^0</math>
#Положим <math>p^0 = r^0</math>
#Устанавливаем счетчик итераций: <math>n = 0</math>
:Итерационный процесс:
#Находим <math>\alpha_k</math>
#По найденному <math>\alpha_k</math> вычисляем <math>s_k</math>
#По найденному <math>s_k</math> вычисляется вспомогательный коэффициент <math>\omega_k</math>
#Находится новое приближение <math>x^{k + 1}</math>
#Вычисляется невязка <math>r^{k + 1}</math>. Если выполнено условие <math>\parallel r^{k + 1} \parallel < \epsilon</math>, то алгоритм завершается.
#Вычисляется вспомогательный коэффициент <math>\beta_k</math>
#Вычисляется новый базисный вектор: <math>p^{k + 1}</math>
#Увеличивается номер итерации: <math>n = n + 1</math>
#Переход к первому шагу итерационного процесса.

=== Вычислительное ядро алгоритма ===
:Вычислительное ядро полностью совпадает с итерационным процессом. Подготовка к итерационному процессу в ядро не включается.

=== Макроструктура алгоритма ===
На каждой итерации алгоритма используются:
# [[Скалярное произведение векторов, вещественная версия, последовательно-параллельный вариант]] x 4 раза
# [[Умножение плотной матрицы на вектор ]] х 2 раза

===Схема реализации последовательного алгоритма===

=== Последовательная сложность алгоритма ===
:Всего в вычислительном блоке алгоритма присутствует 20 трудоемких операций: 2 операции умножения матрицы на вектор, 6 скалярных произведений и 6 сложений/вычитаний векторов и 6 умножений вектора на число.

:Каждое скалярное произведение требует <math>n</math> произведений и <math>n - 1</math> сложение, то есть <math>2n - 1</math> операции. Скалярных произведений всего 6 штук (включая поиск нормы), что дает нам <math>12n - 6</math> операций.

:Умножение матрицы размерности <math>n \times n</math> на вектор эквивалентно взятию еще <math>n</math> скаляров, и так как таких операций в вычислительном ядре 2, то дополнительно имеется еще <math>2n(2n - 1)</math> операций.

:Наконец, сложение или вычитание векторов требует <math>6n</math> соотвествующих операций. Столько же требует 6 произведений вектора на число.

:Итого: <math>2n(2n - 1) + 12n - 6 + 6n + 6n = 4n^2 + 22n - 6</math> операций.

:Нетрудоемкие операции, вроде извлечение квадратного корня и деление вещественных чисел друг на друга, не принимаются в расчет, так как они не влияют на итоговый результат. Окончательно можно заключить, что последовательная сложность алгоритма эквивалента <math>O(n^2)</math>

=== Информационный граф ===
[[file:BiCGStabIterations.jpg|thumb|center|800px|<center>Информационный граф.</center>]]
На графе представлены связи между операциями, выполняющимися в первых трех итерациях метода. При выполнении большего, чем 3, количества итераций, структура каждой новой будет повторять структуру третьей. Связи между итерациями не представлены, т.к. они не важны для понимания параллельной структуры алгоритма. Серым обозначено перемножение чисел, красным - умножение числа на вектор

=== Ресурс параллелизма алгоритма ===
Основной прирост производительности параллельной версии алгоритма дает использование параллельных операций вычисления скалярного произведения, суммы векторов, а так же произведения матрицы на вектор. Каждая из операций вычисления скалярного произведения и суммы векторов, выполняемая на p процессорах, за счет метода сдваивания может ускориться до <math> \frac{p}{\log_2 p} </math> раз. Ускорение же умножения матрицы на вектор может достигать p раз.

Ширина и высота ЯПФ графа данного алгоритма напрямую зависит от конкретных реализаций макроопераций и входных данных.

Для последовательно-параллельной реализации операции взятия скалярного произведения в наиболее оптимальном случае (<math>p= \sqrt n</math>) высота будет равна <math>2 \sqrt n - 1</math>, а ширина <math>\sqrt n</math>, где n - это длина вектора решения.

Высота ЯПФ простейшего алгоритма умножения матрицы на вектор равна 2n, а ширина m, где n - это уже упомянутая длина вектора(она же ширина матрицы), а m - высота матрицы.

Высота ЯПФ операции умножения вектора на число = <math>\frac{n}{p}</math>, а ширина p.

Высота ЯПФ операции вычисления разности векторов = <math> \log_2 p </math>, а ширина p.

В конечном счете общую высоту ЯПФ одной итерации алгоритма можно оценить, как <math>6 \sqrt n-3 + 4n + 3 + 1 + 3*\lceil \frac{n}{p} \rceil + 2* \lceil \frac{n}{p} \rceil = 6 \sqrt n + 4n + 5 \lceil \frac{n}{p} \rceil + 1</math>, а ширину, как <math>2 \sqrt n</math>, если не брать в рассчет проверку критерия сходимости и упрощенности первой итерации по сравнению с остальными.

=== Входные и выходные данные алгоритма ===
:Входные данные
#Матрица <math>A \in R^{N \times N}</math> ( <math>C^{N \times N}</math> )
#Вектор правой части <math>b \in R^N</math> ( <math>C^N</math> )

:Выходные данные:
#Вектор решения СЛАУ <math>x \in R^N</math> ( <math>C^N</math> )

=== Свойства алгоритма ===
:BiCGSTAB хорошо зарекомендовал себя для решения систем линейных алгебраический уравнений, поскольку обладает некоторыми важными свойствами:
#Благодаря применению подхода Петрова-Галеркина и техники ортогонализации, он численно устойчив
#Не меняется вид матрицы в процессе решения
#Эффективен для решения систем большой размерности с разреженной матрицей, поскольку в методе самая трудоемкая операция - умножение матрицы на вектор
#Лучше подходит под распределенные системы, поскольку не содержит операции транспонирования матрицы
#Применим для решения систем с несимметричными матрицами.
#Вычислительная мощность: <math>N/4</math>

== Программная реализация алгоритма ==

=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
==== Локальность реализации алгоритма ====
===== Структура обращений в память и качественная оценка локальности =====
===== Количественная оценка локальности =====
===== Анализ на основе теста Apex-Map =====
=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===
==== Масштабируемость алгоритма ====
==== Масштабируемость реализации алгоритма ====
Исследование масштабируемости реализации стабилизированного метода бисопряженных градиентов проводилось согласно [[Scalability methodology|методике]] на суперкомпьютере "Ломоносов"<ref name="Lom">Воеводин Вл., Жуматий С., Соболев С., Антонов А., Брызгалов П., Никитенко Д., Стефанов К., Воеводин Вад. Практика суперкомпьютера «Ломоносов» // Открытые системы, 2012, N 7, С. 36-39.</ref> [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета].

Набор и границы значений изменяемых [[Глоссарий#Параметры запуска|параметров запуска]] реализации алгоритма:

* число процессоров [4 : 256] с шагом 4;
* размер матрицы [1024 : 5120].

В результате проведённых экспериментов был получен следующий диапазон [[Глоссарий#Эффективность реализации|эффективности реализации]] алгоритма:

* минимальная эффективность реализации 0,11%;
* максимальная эффективность реализации 2,65%.

На следующих рисунках приведены графики [[Глоссарий#Производительность|производительности]] и эффективности выбранной реализации стабилизированного метода бисопряженных градиентов в зависимости от изменяемых параметров запуска.

[[file:Масштабируемость параллельной реализации BiCGSTAB Производительность.png|thumb|center|700px|Параллельная реализация стабилизированного метода бисопряженных градиентов. Изменение производительности в зависимости от числа процессоров и размера матрицы.]]
[[file:Масштабируемость параллельной реализации BiCGSTAB эффективность.png|thumb|center|700px|Параллельная реализация стабилизированного метода бисопряженных градиентов. Изменение эффективности в зависимости от числа процессоров и размера матрицы.]]

[https://github.com/LLNL/hypre/blob/master/src/krylov/HYPRE_bicgstab.c Исследованная параллельная реализация на языке C]

=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===
* Параллельная реализация алгоритма, предложенная MIT: [http://ab-initio.mit.edu/~meep/meep/src/bicgstab.cpp MIT BiCGSTAB]
* Параллельная реализация алгоритма в бесплатной библиотеке, поддерживающей MPI и OpenMP, HYPRE: [http://acts.nersc.gov/hypre/ Официальная страница] [https://github.com/LLNL/hypre/blob/master/src/krylov/bicgstab.c Исходный код]
* Параллельная реализация алгоритма на CUDA в условно бесплатной библиотеке [https://developer.nvidia.com/amgx/ NVIDIA AmgX]

== Литература ==

Обсуждение участницы:Александра

2016-11-16T13:25:42Z

Algoman:

== Замечания к [[Участник:Александра/Метод_встречи_посередине]] ==

1) отсутствует оценка объёма входных данных на врезке в начале статьи

2) пункты 2.1 и 2.2 должны быть 2.4 и 2.7, согласно формату описания [[Структура_описания_свойств_алгоритмов]]

== Замечания к пункту 2.4 от 16.11.2016 ==

* в чём измерялась произвоидтельность в пункте? требуется указать

Участница:Александра/Метод встречи посередине

2016-11-16T13:24:17Z

Algoman:

{{algorithm
| name = Метод встречи посередине
| serial_complexity = <math>O(\sqrt n\log(n))</math>
| pf_height = <math>O(1)</math>
| pf_width = <math>O(n)</math>
| input_data = <math>O(\log(n))</math>
| output_data = <math>\log(n)</math>
}}

Автор описания: [[Участник:Александра|А.В.Батарина]]

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===
Метод "Встреча посередине" криптоанализа блочных шифров был впервые предложен в 1977 году Уитфилдом Диффи и Мартином Хеллманом <ref>(June 1977) «Exhaustive Cryptanalysis of the NBS Data Encryption Standard». Computer 10 (6): 74–84. DOI:10.1109/C-M.1977.217750</ref>. Встреча посередине используется для ускорения перебора ключей шифра за счёт увеличения требуемой памяти. Метод применим в случае каскадного построения сложного шифра из нескольких простых, другими словами, в случае последовательного применения шифрующих преобразований на разных ключах к блокам открытого текста.

В качестве примера шифра, поддающегося атаке "встреча посередине" можно привести криптоалгоритм 2DES, являющийся модификацией шифра DES. В 2DES открытый текст шифруется дважды алгоритмом DES на двух разных 56-битных ключах. Однако из-за атаки "встреча посередине" сложность перебора двойного ключа (112 бит) шифра 2DES составляет <math>2^{57}</math> вместо ожидаемых <math>2^{112}</math>.

=== Математическое описание алгоритма ===

'''Исходные данные:''' открытый текст <math>x</math>, шифртекст <math>y</math>.

Алгоритм зашифрования — композиция двух преобразований <math>T_1(x,k_1)</math> и <math>T_2(x,k_2)</math>, т.е. <math>y=T_2(T_1(x,k_1),k_2)</math>.

Алгоритм расшифрования — <math>y=T_1^{-1}(T_2^{-1}(x,k_2),k_1)</math>

'''Вычисляемые данные:''' ключи шифрования <math>k_1 \in K_1</math>, <math>k_2 \in K_2</math>, где <math>K_1, K_2</math> — множества возможных ключей.

Трудоёмкость полного перебора всех возможных пар <math>k_1,k_2</math> составляет в среднем <math>\frac{|K_1||K_2|}{2}</math>, а в худшем случае <math>|K_1||K_2|</math>. Однако используя дополнительную память, можно сократить перебор.

Предположим, что открытый текст <math>x</math> и шифртекст <math>y</math> однозначно определяют ключи <math>k_1,k_2</math>. Составим две таблицы:

<math>
\begin{align}
z_1 & =T_1(x,k_1^1) & z_1^' &=T_2^{-1}(x,k_2^1)\\\\
z_2 & =T_1(x,k_1^2) & z_2^' & =T_2^{-1}(x,k_2^2)\\
... & ................. & ... & .................... \\
z_{|K_1|} & =T_1(x,k_1^{|K_1|}) & z_{|K_1|}^' & =T_2^{-1}(x,k_2^{|K_1|})
\end{align}
</math>

Для всех <math>k_1^i \in K_1</math>, <math>k_2^j \in K_2</math>. Далее таблицы объединяются и сортируются по значениям <math>z_i,z_j^'</math>. Индексы <math>i,j</math>, при которых <math>z_i=z_j^'</math>, однозначно определяют искомую пару ключей <math>k_1=k_1^i,k_2=k_2^j</math>. Для нахождения такой пары достаточно просмотреть отсортированную таблицу один раз.

Если же пара открытый текст/шифртекст определяет ключ не единственном образом, то выходом алгоритма будет некоторое множество пар <math>k_1,k_2</math>, одна из которых является истинным ключом. Для выбора истинного ключа достаточно проверить ключи из полученного множества на других парах открытый текст/шифртекст.

==== Оптимизации ====

1. От генерации второй таблицы со значениями <math>z_j^'</math> можно отказаться, перебирая ключи <math>k_2^j</math> до того момента, когда значение <math>z_j^'</math> совпадёт с одним из значений <math>z_i</math>. В таком случае опробование ключей <math>k_2^j</math> в среднем сократится вдвое. Также вдвое сократится объём используемой памяти. Для нахождения совпадающего значения в отсортированном массиве можно применить бинарный поиск.

2. Вместо сортировки таблицы со значениями <math>z_i</math> и последующего бинарного поиска можно использовать хэш-таблицу.

=== Вычислительное ядро алгоритма ===
В случае использования хэш-таблицы достаточно большого размера основную сложность алгоритма составляет опробование ключей <math>k_1,k_2</math>.
Одним из самых трудоёмких шагов также оказывается сортировка таблицы.

=== Макроструктура алгоритма ===

Как видно из описания, атака "встреча посередине" использует (или может использовать в качестве оптимизации) следующие алгоритмы:

1. Алгоритм зашифрования/расшифрования

2. Алгоритм сортировки

3. Алгоритмы поиска, вставки в хэш-таблицу

=== Схема реализации последовательного алгоритма ===

Далее приводится последовательность действий для варианта алгоритма с генерацией одной таблицы значений <math>z_i</math>.

1. Вычислить таблицу <math>z_i</math>, записывая значения в порядке вычисления или используя хэш-таблицу

2. В случае записи значений в порядке вычисления отсортировать массив

3. Опробовать ключи <math>k_2^j</math>, ища совпадения с таблицей значений <math>z_j^'</math>. Для нахождения совпадения использовать поиск по хэш-таблице (если она есть) или бинарный поиск

=== Последовательная сложность алгоритма ===
Всюду далее считаем, что алгоритм не прекращает работу при нахождении первого совпадения, а ищет все совпадения.

1. Сложность вычисления таблиц значений <math>z_i,z_j^'</math> составит <math>O(|K_1|+|K_2|)</math> операций опробования

2. Объединение таблиц и их сортировка будет иметь сложность <math>O((|K_1|+|K_2|)\log(|K_1|+|K_2|))</math> (например, при сортировке слиянием).

3. Сложность бинарного поиска в отсортированном массиве — <math>O(log_2(|K_1|))</math> для каждого поиска

4. Сложность поиска в достаточно большой хэш-таблице составит <math>O(1)</math> для каждого поиска

Итого асимптотическая сложность алгоритма:

1. С генерацией двух таблиц — <math>O(|K_1|+|K_2|) + O((|K_1|+|K_2|)\log(|K_1|+|K_2|)) + O(|K_1|+|K_2|)=O((|K_1|+|K_2|)\log(|K_1|+|K_2|))</math>

2. C генерацией одной таблицы, сортировкой и бинарным поиском — <math>O(|K_1|) + O((|K_1|)\log(|K_1|)) + O(|K_2|\log_2(|K_1|))=O(max(|K_1|,|K_2|)\log(|K_1|))</math>

3. C генерацией одной (достаточно большой) хэш-таблицы — <math>O(|K_1|) + O(|K_2|)=O(|K_1|+|K_2|)</math>

Пусть n - количество всевозможных пар <math>k_1,k_2</math> и пусть <math>|K_1|=|K_2|</math>. В этом случае <math>|K_1|=|K_2|=\sqrt n</math>.

Тогда сложность алгоритма в первых двух пунктах составляет <math>O(\sqrt n\log(n))</math>, в третьем — <math>O(\sqrt n)</math>.

=== Информационный граф ===

Опишем информационный граф алгоритма. На вход подаётся открытый (Open) и закрытый (Close), т.е. зашифрованный, текст. Далее открытый текст шифруется (Enc) на ключах <math>k_1^i</math>, а зашифрованный расшифровывается (Dec) на ключах <math>k_2^j</math>. Далее полученные криптограммы сравниваются (Cmp) и все ключи, на которых они совпали, являются выходом алгоритма.

[[file:meet.png|thumb|center|900px|Рисунок 1. Граф алгоритма c отображением входных и выходных данных. Open — открытый текст, Close — шифртекст, Enc — операция зашифрования, Dec — операция расшифрования, Cmp — операция сравнения, Keys — вычисленные ключи]]

=== Ресурс параллелизма алгоритма ===

Как видно из информационного графа, для реализации атаки "встреча посередине" в параллельном варианте потребуются выполнение следующих двух ярусов (в предположении, что <math>|K_1|=|K_2|</math>):

1. <math>\sqrt n</math> зашифрований и столько же расшифрований

2. <math>n</math> сравнений

Таким образом, высота ЯПФ составляет 2, ширина - <math>n</math>.

=== Входные и выходные данные алгоритма ===

'''Вход:'''
На вход подаётся открытый текст <math>x</math> и шифртекст <math>y</math>, а также алгоритм зашифрования/расшифрования. В случае блочного шифра открытым текстом и шифртекстом является последовательность блоков. Для атаки "встреча посередине", как правило, берётся один блок для максимального ускорения операций зашифрования и расшифрования.

'''Выход:'''
Результатом работы алгоритма является множество пар <math>k_1^i,k_2^j</math>, для которых нашлись совпадения. Только одна из пар является настоящим ключом. Чтобы отсеять лишние, необходимо проверить все пары на блоках открытого и шифрованного текста, которые в алгоритме не использовались.

=== Свойства алгоритма ===
Соотношением последовательной и параллельной сложности алгоритма является <math>O(\sqrt n\log(n))</math>.

Будем считать, что размер входных данных (открытый текст и шифртекст) совпадает с размером ключа (на практике это сравнимые величины), а сортировка слиянием делит массивы пополам. Тогда вычислительная мощность алгоритма — <math>O(\sqrt n)</math>.

Дуги информационного графа, исходящие из вершин зашифрования и расшифрования, образуют пучки мощности <math>\sqrt n</math>, т.е. из каждой такой вершины выходит <math>\sqrt n</math> дуг. Длинных дуг в алгоритме нет. В случае поиска всех пар ключей с совпадающими криптограммами алгоритм полностью детерминирован.

== Программная реализация алгоритма ==

=== Особенности реализации последовательного алгоритма ===

=== Локальность данных и вычислений ===

=== Возможные способы и особенности параллельной реализации алгоритма ===

=== Масштабируемость алгоритма и его реализации ===
==== Масштабируемость алгоритма ====
==== Масштабируемость реализации алгоритма ====
Исследование масштабируемости реализации алгоритма проводилось на суперкомпьютере "Ломоносов"<ref name="Lom">Воеводин Вл., Жуматий С., Соболев С., Антонов А., Брызгалов П., Никитенко Д., Стефанов К., Воеводин Вад. Практика суперкомпьютера «Ломоносов» // Открытые системы, 2012, N 7, С. 36-39.</ref> [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета]. Изменяемые параметры запуска:
* Размер ключа – от 8 до 20 бит с шагом 1
* Число ядер – от 1 до 8 (значения являются степенью числа 2)
Ниже представлен график зависимости [[Глоссарий#Производительность|производительности]] от числа ядер и размера ключа (размер задачи – экспоненциальная функция от размера ключа).
[[File:Масштабируемость.jpg|thumb|center|900px|Рисунок 2. Масштабируемость реализации алгоритма]]

Как видно из графика, производительность почти не изменяется в зависимости от размера задачи, в то время как зависимость производительности от числа ядер визуально близка к линейной. Это связано с тем, что алгоритм содержит большое количество независимых операций опробования ключа, синхронизация между параллельно выполняющимися опробованиями не требуется.

[https://github.com/AlBatarina/Super2016/blob/master/meet_in_the_middle/meet.c Исследованная параллельная реализация на языке C]

=== Динамические характеристики и эффективность реализации алгоритма ===

=== Выводы для классов архитектур ===

=== Существующие реализации алгоритма ===

Одна из реализаций атаки "встреча посередине" с использованием хэш-таблицы представлена в свободном доступе по ссылке [https://gist.github.com/dchest/1062437 github]

== Литература ==

<references \>

Обсуждение участника:EasyBreezy

2016-11-16T13:21:45Z

Algoman:

== Замечания к [[Участник:EasyBreezy/Стабилизированный_метод_биспоряженных_градиентов_(BiCGSTAB)]] ==

Все еще отсутствует:

1) пропущен пункт 1.5 "Схема реализации последовательного алгоритма" из-за чего сбита нумерация первой части, см [[Структура_описания_свойств_алгоритмов]]

Пункт пропущен в следствии того, что является избыточным, все шаги по реализации последовательного алгоритма уже содержаться в пункте "Математическое описание".
Можем просто повторить содержимое математического описания, но на мой взгляд это не имеет смысла

[[Участник:Algoman|Algoman]] ([[Обсуждение участника:Algoman|обсуждение]]) 16:21, 16 ноября 2016 (MSK)
Пункт 1.5 не является избыточным - в нём более описывается то же, что в и 1.2, но боллее схематично и наглядно для беглого восприятия: в виде псевдокода/блок схема. Дублирование не нужно. Даже в случае его умышленного пропуска нумерация пунктов не должна быть сбита.

== Замечания к пункту 2.4 от 16.11.2016 ==

* картинки не работают
* какие выводы можно сделать о масштабируемости алгоритма, исходя из полученных данных? Требуется явно написать это в пункте.

Обсуждение участника:EasyBreezy

2016-11-16T13:15:35Z

Algoman:

Участник:Sergey Lavrushkin/EM-алгоритм кластеризации

2016-11-16T13:04:54Z

Algoman:

{{algorithm
| name = EM-алгоритм кластеризации (1 итерация)
| serial_complexity = <math>O(nkq^2)</math>
| pf_height = <math>O(\log{nk})</math>
| pf_width = <math>O(nk)</math>
| input_data = <math>nq + 1</math>
| output_data = <math>k(n + q^2 + q + 1)</math>
}}
Автор статьи: [[Участник: Sergey Lavrushkin|Сергей Лаврушкин]] (группа 620)

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===

==== EM-алгоритм ====
EM-алгоритм (англ. expectation-maximization) — алгоритм, используемый в математической статистике для нахождения оценок максимального правдоподобия параметров вероятностных моделей, в случае, когда модель зависит от некоторых скрытых переменных. Каждая итерация алгоритма состоит из двух шагов. На E-шаге (expectation) вычисляется ожидаемое значение функции правдоподобия, при этом скрытые переменные рассматриваются как наблюдаемые. На M-шаге (maximization) вычисляется оценка максимального правдоподобия, таким образом увеличивается ожидаемое правдоподобие, вычисляемое на E-шаге. Затем это значение используется для E-шага на следующей итерации. Алгоритм выполняется до сходимости.<ref>ЕМ-алгоритм, его модификации и обобщения [http://www.machinelearning.ru/wiki/index.php?title=EM-%D0%B0%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC http://www.machinelearning.ru/wiki/index.php?title=EM-алгоритм]</ref>

Как правило, ЕМ-алгоритм применяется для решения задач двух типов:
* К первому типу можно отнести задачи, связанные с анализом действительно неполных данных, когда некоторые статистические данные отсутствуют в силу каких-либо причин.
* Ко второму типу задач можно отнести те задачи, в которых функция правдоподобия имеет вид, не допускающий удобных аналитических методов исследования, но допускающий серьезные упрощения, если в задачу ввести дополнительные «ненаблюдаемые» (скрытые, латентные) переменные. Примерами прикладных задач второго типа являются задачи распознавания образов, реконструкции изображений. Математическую суть данных задач составляют задачи кластерного анализа, классификации и разделения смесей вероятностных распределений.

Алгоритм основан на методике итеративного вычисления оценок максимального правдоподобия, предложенной в 1977 г. (A. P. Demster, N. M. Laird, D. B. Rubin. Maximum Likelihood from Incomplete Data via the EM Algorithm).<ref> A. Dempster, N. Laird and D. Rubin. Maximum likelihood estimation from incomplete data. – Journal of the Royal Statistical Society, Series B, 1977, vol. 39, p. 1-38.</ref>

==== Кластеризация с помощью EM-алгоритма ====

Кластеризация — задача разбиения заданной выборки объектов (ситуаций) на непересекающиеся подмножества, называемые кластерами, так, чтобы каждый кластер состоял из схожих объектов, а объекты разных кластеров существенно отличались <ref>Кластеризация [http://www.machinelearning.ru/wiki/index.php?title=%D0%9A%D0%BB%D0%B0%D1%81%D1%82%D0%B5%D1%80%D0%B8%D0%B7%D0%B0%D1%86%D0%B8%D1%8F http://www.machinelearning.ru/wiki/index.php?title=Кластеризация]</ref>. В основе идеи применения EM-алгоритма для кластеризации лежит предположение, что исследуемое множество данных может быть смоделировано с помощью линейной комбинации многомерных нормальных распределений, а целью является оценка параметров распределения, которые максимизируют логарифмическую функцию правдоподобия, используемую в качестве меры качества модели. К оцениваемым параметрам относятся математические ожидания и ковариационные матрицы. Предполагается, что любое наблюдение принадлежит ко всем кластерам, но с разной вероятностью. Задача заключается в "подгонке" распределений смеси к данным, а затем в определении вероятностей принадлежности наблюдения к каждому кластеру. Наблюдение должно быть отнесено к тому кластеру, для которого данная вероятность выше.

Алгоритм EM основан на вычислении расстояний. Он может рассматриваться как обобщение кластеризации на основе анализа смеси вероятностных распределений. В процессе работы алгоритма происходит итеративное улучшение решения, а остановка осуществляется в момент, когда достигается требуемый уровень точности модели. Мерой в данном случае является монотонно увеличивающаяся статистическая величина, называемая логарифмическим правдоподобием.<ref>EМ — масштабируемый алгоритм кластеризации [https://basegroup.ru/community/articles/em https://basegroup.ru/community/articles/em]</ref>

=== Математическое описание алгоритма ===
Исходные данные:
* <math>k</math> — число кластеров,
* <math>X =\{x_{1}, x_{2}, ..., x_{n}\}</math> — множество из <math>n</math> наблюдений размерности <math>q</math>: <math>x_{i} = (x_{i1}, ..., x_{iq})</math>.
Вычисляемые данные:
* <math>(w, \theta) = (w_1, ..., w_k; \mu_1, ..., \mu_k; \Sigma_1, ..., \Sigma_k)</math> — параметры смеси гауссовых распределений,
* <math>Y</math> — матрица размера <math>n \times k</math> с вероятностями членства в кластерах.
==== Постановка задачи разделения смеси гауссовых распределений ====
Пусть <math>w_1, ..., w_k</math> — априорные вероятности кластеров, <math>p_1(x), ..., p_k(x)</math> — плотности распределения кластеров.
Тогда плотность распределения вектора признаков <math>x</math> сразу по всем кластерам равна:
:<math>
\begin{align}
p(x) = \sum_{j=1}^{k}w_jp_j(x)
\end{align}
</math>
Необходимо на основе выборки оценить параметры модели <math>w_1, ..., w_k, p_1(x), ..., p_k(x)</math>. Это позволит оценивать вероятность принадлежности к кластеру и, таким образом, решить задачу кластеризации. Такая задача
называется задачей разделения смеси распределений:
:<math>
\begin{align}
p(x) = \sum_{j=1}^{k}w_jp_j(x),\quad p_j(x) = \phi(\theta_j; x),
\end{align}
</math>
где <math>\theta_j</math> — параметры распределения <math>p_j(x)</math>.
В случае смеси гауссовых распределений в <math>q</math>-мерном пространстве признаков <math>\phi(\theta_j; x)</math> имеют следующий вид:
:<math>
\begin{align}
\phi(\theta_j; x) = \frac{1}{\Big(2\pi\Big)^{\frac{q}{2}}\sqrt{|\Sigma_j|}}\exp{\bigg\{-\frac{\delta^2}{2}\bigg\} },
\end{align}
</math>
где:
* <math>\Sigma_j</math> — ковариационная матрица размером <math>q \times q</math>,
* <math>\mu_j</math> — <math>q</math>-мерный вектор математических ожиданий,
* <math>\delta^2 = \Big( x - \mu_j \Big)^T \Sigma_j^{-1} \Big( x - \mu_j \Big)</math> — квадратичное расстояние Махаланобиса.
В случае смеси гауссовых распределений получаем, что <math>\theta_j = (\mu_j, \Sigma_j)</math>. То есть для решения задачи разделения смеси гауссовых распределений необходимо оценить вектор параметров <math>(w, \theta) = (w_1, ..., w_k; \mu_1, ..., \mu_k; \Sigma_1, ..., \Sigma_k)</math>. Согласно принципу максимизации правдоподобия:
:<math>
\begin{align}
w, \theta = \underset{w, \theta}{\operatorname{argmax}} \sum_{i=1}^{n}\ln{p(x_i)} = \underset{w, \theta}{\operatorname{argmax}} \sum_{i=1}^{n}\ln{\sum_{j=1}^{k}w_jp_j(x_i)}
\end{align}
</math>
Таким образом, имеет место задача максимизации суммы логарифмов сумм, решение которой представляет большую трудность. В таком случае полезным оказывается итеративный метод решения — EM-алгоритм.<ref>Поиск структуры в данных — Lecture 9 — Expectation Maximization (EM-алгоритм) [https://www.coursera.org/learn/unsupervised-learning/lecture/2jhbI/expectation-maximization-em-alghoritm https://www.coursera.org/learn/unsupervised-learning/lecture/2jhbI/expectation-maximization-em-alghoritm]</ref>

==== EM-алгоритм ====
Оптимальные параметры задачи разделения смеси гауссовых распределений отыскиваются последовательно с помощью итерационного EM-алгоритма. Основная идея – вводится вспомогательный вектор скрытых переменных. Это позволяет свести сложную оптимизационную задачу к последовательности итераций по пересчету коэффициентов (скрытых переменных по текущему приближению вектора параметров - E-шаг) и максимизации правдоподобия (с целью найти следующее приближение вектора - М-шаг).<ref>EM алгоритм (пример) [http://www.machinelearning.ru/wiki/index.php?title=EM_%D0%B0%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_(%D0%BF%D1%80%D0%B8%D0%BC%D0%B5%D1%80) http://www.machinelearning.ru/wiki/index.php?title=EM_алгоритм_(пример)]</ref>

EM-алгоритм заключается в следующем:
<ol>
<li> В начале работы алгоритма задаются параметры начального приближения. Наиболее общим способом инициализации является присвоение элементам матрицы математических ожиданий случайных значений <math> \mu_j \leftarrow Random </math>, начальные ковариационные матрицы определяются как единичные <math>\Sigma_j \leftarrow I</math>, веса кластеров задаются одинаковыми <math>w_i \leftarrow \frac{1}{k}</math>. Также в качестве начальных параметров можно использовать результат работы алгоритма K-means. (Данная эвристика применяется, так как K-means требуется намного меньше итераций до достижения стабилизации, в то время как каждый шаг EM требует больших вычислительных затрат).</li>
<li> Далее итеративно выполняется следующая пара процедур:
<ul>
<li>E-шаг: используя текущее значение вектора параметров <math>(w, \theta) = (w_1, ..., w_k; \mu_1, ..., \mu_k; \Sigma_1, ..., \Sigma_k)</math>, вычисляются значения скрытых переменных <math>y_{ij}</math>:
:<math>
\begin{align}
& y_{ij} = \frac{w_j p_j(x_i)}{\sum_{l=1}^{k}w_lp_l(x_i)}
\end{align}
</math></li>
<li>М-шаг: переоценка вектора параметров, используя текущие значения скрытых переменных:
:<math>
\begin{align}
& n_j = \sum_{i = 1}^{n}y_{ij}, \\
& \mu_j^{new} = \frac{1}{n_j} \sum_{i = 1}^{n}y_{ij}x_i, \\
& \Sigma_j^{new} = \frac{1}{n_j} \sum_{i = 1}^{n}y_{ij}(x_i - \mu_j^{new})(x_i - \mu_j^{new})^T,\\
& w_j^{new} = \frac{n_j}{n}.
\end{align}
</math></li>
</ul>
</li>
</ol>
Итерации происходят до сходимости (норма разности векторов скрытых переменных или изменение логарифмического правдоподобия на каждой итерации не будет превышать заданную константу) или достижения максимального числа итераций.

=== Вычислительное ядро алгоритма ===
В вычислительное ядро EM-алгоритма входят:
* Вычисление скрытых переменных <math>y_{ij}</math> на E-шаге (всего их <math>nk</math>).
* Переоценка вектора параметров <math>(w_1, ..., w_k; \mu_1, ..., \mu_k; \Sigma_1, ..., \Sigma_k)</math> на M-шаге, используя текущие значения скрытых переменных <math>y_{ij}</math>.

=== Макроструктура алгоритма ===
Как записано в описании ядра алгоритма, основную часть метода составляют множественные вычисления скрытых переменных <math>y_{ij}</math> на E-шаге и обновление вектора параметров <math>(w_1, ..., w_k; \mu_1, ..., \mu_k; \Sigma_1, ..., \Sigma_k)</math> на M-шаге.
Также стоит выделить вычисление определителя и обратной матрицы ковариационных матриц <math>\Sigma_j</math> в начале E-шага.

=== Схема реализации последовательного алгоритма ===
Последовательная реализация алгоритма EM может быть проиллюстрирована с помощью следующего псевдокода:
# '''Инициализация''': установка начальных значений <math>\mu, \, \Sigma_j \, (j = \overline{1, k}), \, w</math>.
# '''Пока''' изменение логарифмического правдоподобия <math>\Delta llh \geq \epsilon</math> и не достигнуто максимальное число итераций <math>m</math>, '''выполнять''' шаги E и M.
'''Шаг E'''

'''def''' E-step:
'''Инициализировать''' нулевыми значениями <math>\mu^{'}, \, \Sigma_j^{'} \, (j = \overline{1, k}), \, w^{'}, \, llh</math>
'''for''' <math>j = \overline{1, k}</math>:
'''Вычислить''' определитель и обратную матрицу матрицы <math>\Sigma_j</math>
'''for''' <math>i = \overline{1, n}</math>:
<math>sump_i = 0</math>
'''for''' <math>j = \overline{1, k}</math>:
<math>\delta_{ij}^2 = \big( x_i - \mu_j \big)^T \Sigma_j^{-1} \big( x_i - \mu_j \big)</math>
<math>g_{ij} = \frac{w_j}{{(2 \pi)}^\frac{q}{2}\sqrt{|\Sigma_j|}}\exp{\big\{-\frac{\delta_{ij}^2}{2}\big\} }</math>
<math>sump_i \mathrel{+}= g_{ij}</math>
<math>y_i = \frac{g_i}{sump_i}</math>
<math>llh \mathrel{+}= \ln(sump_i)</math>
<math>\mu^{'} \mathrel{+}= x_iy_i^T</math>
<math>w^{'} \mathrel{+}= y_i</math>

'''Шаг M'''

'''def''' M-step:
'''for''' <math>j = \overline{1, k}</math>:
<math>\mu_j = \frac{\mu_j^{'}}{w_j^{'}}</math>
'''for''' <math>i = \overline{1, n}</math>:
<math>\Sigma_j^{'} \mathrel{+}= (x_i - \mu_j)y_{ij}(x_i - \mu_j)^T</math>
<math>\Sigma_j = \frac{\Sigma_j^{'}}{w_j^{'}}</math>
<math>w = \frac{w^{'}}{n}</math>
Логаририфмическое правдоподобие вычисляется как:
:<math>
\begin{align}
llh=\sum_{i=1}^{n}\ln{(sump_i)}
\end{align}
</math>
Матрицы <math>\mu^{'}, \, \Sigma_j^{'} \, (j = \overline{1, k}), \, w^{'}</math> являются временными и используются только для вычислений.

=== Последовательная сложность алгоритма ===
Последовательная сложность одной итерации EM-алгоритма:
<ol>
<li> E-шаг: 
В случае недиагональных ковариационных матриц сложность вычислений:
* Определителей ковариационных матриц <math>|\Sigma_j|</math> (<math>j = \overline{1, k}</math>) методом Гаусса: <math>O(kq^3)</math>,
* Матриц, обратных ковариационным матрицам <math>\Sigma_j^{-1}</math> (<math>j = \overline{1, k}</math>) методом Гаусса-Жордана: <math>O(kq^3)</math>,
* Скрытых переменных <math>y_{ij}</math> (<math>i = \overline{1, n}, j = \overline{1, k}</math>): <math>O(nkq^2)</math>.
В случае диагональных ковариационных матриц сложность вычислений:
* Определителей ковариационных матриц <math>|\Sigma_j|</math> (<math>j = \overline{1, k}</math>): <math>O(kq)</math>,
* Матриц, обратных ковариационным матрицам <math>\Sigma_j^{-1}</math> (<math>j = \overline{1, k}</math>): <math>O(kq)</math>,
* Скрытых переменных <math>y_{ij}</math> (<math>i = \overline{1, n}, j = \overline{1, k}</math>): <math>O(nkq)</math>.
Получаем, что последовательная сложность E-шага в случае недиагональных ковариационных матриц имеет порядок <math>O(kq^3 + nkq^2)</math>, а в случае диагональных ковариационных матриц — <math>O(nkq)</math>.
</li>
<li>
М-шаг: 
В случае недиагональных ковариационных матриц сложность вычислений:
* Обновление математических ожиданий <math>\mu_j</math> (<math>j = \overline{1, k}</math>): <math>O(nkq)</math>,
* Обновление ковариационных матриц <math>\Sigma_j</math> (<math>j = \overline{1, k}</math>): <math>O(nkq^2)</math>,
* Обновление весов кластеров <math>w_j</math> (<math>j = \overline{1, k}</math>): <math>O(nk)</math>.
В случае диагональных ковариационных матриц сложность вычислений:
* Обновление математических ожиданий <math>\mu_j</math> (<math>j = \overline{1, k}</math>): <math>O(nkq)</math>,
* Обновление ковариационных матриц <math>\Sigma_j</math> (<math>j = \overline{1, k}</math>): <math>O(nkq)</math>,
* Обновление весов кластеров <math>w_j</math> (<math>j = \overline{1, k}</math>): <math>O(nk)</math>.
Получаем, что последовательная сложность М-шага в случае недиагональных ковариационных матриц имеет порядок <math>O(nkq^2)</math>, а в случае диагональных ковариационных матриц — <math>O(nkq)</math>.
</li>
</ol>
Таким образом, последовательная сложность итерации EM-алгоритма в случае недиагональных ковариационных матриц имеет порядок <math>O(kq^3 + nkq^2)</math>, а в случае диагональных ковариационных матриц — <math>O(nkq)</math>. При этом, обычно размерность элементов выборки <math>q</math>, также как и число кластеров <math>k</math>, значительно меньше числа элементов выборки <math>n</math> (<math>k \ll n, q \ll n</math>), поэтому в случае недиагональных ковариационных матриц сложность может быть записана в виде <math>O(nkq^2)</math>.

=== Информационный граф ===

Граф алгоритма в терминах E-шагов и M-шагов представлен на рис. 1. Каждая итерация алгоритма зависит от результата работы предыдущей итерации, M-шаг зависит от результата E-шага.

[[Файл:EM-alg-Lavrushkin.png|thumb|1000px|center|Рисунок 1. Граф EM-алгоритма. <math>k</math> — число кластеров; <math>X</math> — множество наблюдений; <math>Y</math> — матрица с вероятностями членства в кластерах.]]

Рассмотрим по отдельности информационные графы E-шага и M-шага.

==== E-шаг ====
Опишем граф E-шага как аналитически, так и в виде рисунка.

Граф алгоритма состоит из четырех групп вершин:
*'''Первая''' группа вершин соответствует вычислению обратных матриц и определителей ковариационных матриц. Число вершин: <math>k</math>. Аргументом этой операции является ковариационная матрица <math>\Sigma_j</math>. Результат срабатывания операции является промежуточным данным алгоритма.
*'''Вторая''' группа вершин соответствует вычислению <math>g_{ij} = \frac{w_j}{{2 \pi}^\frac{q}{2}|\Sigma_j|}\exp{\big\{-\frac{1}{2} \big( x_i - \mu_j \big)^T \Sigma_j^{-1} \big( x_i - \mu_j \big) \big\}}</math>. Число вершин: <math>nk</math>. Аргументами этой операции являются вес кластера <math>w_j</math>, математическое ожидание <math>\mu_j</math>, ковариационная матрица <math>\Sigma_j</math>, элемент выборки <math>x_i</math>. Результат срабатывания операции является промежуточным данным алгоритма.
*'''Третья''' группа вершин соответствует вычислению нормировочных коэффициентов <math>\sum_{l=1}^{k}g_{ij}</math>. Число вершин: <math>n</math>. Аргументами этой операции являются значения <math>g_{ij}, \, j = \overline{1, k}</math>. Результат срабатывания операции является промежуточным данным алгоритма.
*'''Четвертая''' группа вершин соответствует вычислению скрытых переменных <math>y_{ij}</math>. Число вершин: <math>nk</math>. Аргументами этой операции являются значение <math>g_{ij}</math> и нормировочный коэффициент. Результат срабатывания операции является выходным данным алгоритма.

Описанный граф представлен на рис.2 и рис.3. Здесь вершины одной группы расположены в одной строке. Вершины-операции обозначены синим цветом, вершины-данные — оранжевым.

[[Файл:E-step-Lavrushkin.png|thumb|1000px|center|Рисунок 2. Граф E-шага.]]
[[Файл:E-step2-Lavrushkin.png|thumb|800px|center|Рисунок 3. Граф E-шага с с отображением входных и выходных данных.]]

==== M-шаг ====
Опишем граф M-шага как аналитически, так и в виде рисунка.

Граф алгоритма состоит из четырех групп вершин:
*'''Первая''' группа вершин соответствует вычислению нормировочных коэффициентов <math>n_j</math>. Число вершин: <math>k</math>. Аргументами этой операции являются скрытые переменные <math>y_{ij}, \, i = \overline{1, n}</math>. Результат срабатывания операции является промежуточным данным алгоритма.
*'''Вторая''' группа вершин соответствует вычислению математических ожиданий <math>\mu_j</math>. Число вершин: <math>k</math>. Аргументами этой операции являются множество наблюдений <math>X</math>, скрытые переменные <math>y_{ij}, \, i = \overline{1, n}</math>, нормировочный коэффициент <math>n_j</math>. Результат срабатывания операции является выходным данным алгоритма.
*'''Третья''' группа вершин соответствует вычислению ковариационных матриц <math>\Sigma_j</math>. Число вершин: <math>k</math>. Аргументами этой операции являются множество наблюдений <math>X</math>, скрытые переменные <math>y_{ij}, \, i = \overline{1, n}</math>, нормировочный коэффициент <math>n_j</math>, математическое ожидание <math>\mu_j</math>. Результат срабатывания операции является выходным данным алгоритма.
*'''Четвертая''' группа вершин соответствует вычислению весов кластеров <math>w_{j}</math>. Число вершин: <math>k</math>. Аргументом этой операции является нормировочный коэффициент <math>n_j</math>. Результат срабатывания операции является выходным данным алгоритма.

Описанный граф представлен на рис.4 и рис.5. Здесь вершины одной группы расположены в одной строке. Вершины-операции обозначены синим цветом, вершины-данные — оранжевым.

[[Файл:M-step-Lavrushkin.png|thumb|1000px|center|Рисунок 4. Граф M-шага.]]
[[Файл:M-step2-Lavrushkin.png|thumb|600px|center|Рисунок 5. Граф M-шага с отображением входных и выходных данных.]]

Графы вычисления математических ожиданий <math>\mu_j</math> и ковариационных матриц <math>\Sigma_j</math> представлены на рис. 6 и рис. 7.

[[Файл:EM-alg-mean-Lavrushkin.png|thumb|1400px|center|Рисунок 6. Граф вычисления математического ожидания <math>\mu_j</math>.]]
[[Файл:EM-alg-cov-Lavrushkin.png|thumb|1400px|center|Рисунок 7. Граф вычисления ковариационной матрицы <math>\Sigma_j</math>.]]

=== Ресурс параллелизма алгоритма ===

По графам из пункта 1.7 видно, что скрытые переменные <math>y_{ij}</math> в E-шаге, <math>y_{ij}x_i</math> в вычислении математических ожиданий <math>\mu_{j}</math> и <math>y_{ij}(x_i - \mu_j)(x_i - \mu_j)</math> в вычислении ковариационных матриц <math>\Sigma_{j}</math> в M-шаге вычисляются независимо (<math>i = \overline{1, n}, \, j = \overline{1, k}</math>). Таким образом, при условии наличия неограниченного числа процессоров эти операции можно распараллелить как по числу наблюдений, так и по числу кластеров. Однако в отсутствии неограниченного числа процессорв целесообразно проводить распараллеливание по числу наблюдений, потому что, как правило, число наблюдений значительно больше числа кластеров (<math>n \gg q</math>).

При классификации по ширине ЯПФ его сложность будет <math>O(nk)</math>. Сложность ЯПФ при классификации по высоте зависит от способа вычисления обратных матриц и определителей ковариационных матриц, а также от способа суммирования при вычислении скрытых переменных и обновлении вектора параметров. Предположим, что размерность элементов выборки <math>q</math> и число кластеров <math>k</math> значительно меньше числа элементов выборки <math>n</math> (<math>k \ll n, q \ll n</math>). Тогда вычисление обратных матриц и определителей ковариационных матриц можно не учитывать. Пусть для вычисления сумм используется пирамида сдваиванием. Тогда сложность суммирования при вычислении скрытых переменных равна <math>O(\log{k})</math>, а при обновлении вектора параметров — <math>O(\log{n})</math>. Следовательно, при классификации по высоте ЯПФ его сложность будет <math>O(\log{nk})</math>.

=== Входные и выходные данные алгоритма ===
'''Входные данные''': <math>k</math> — число кластеров; <math>X =\{x_{1}, x_{2}, ..., x_{n}\}</math> — множество из <math>n</math> наблюдений <math>q</math>-мерного пространства.

'''Объем входных данных''': <math>nq + 1</math>.

'''Выходные данные''': <math>(w, \theta) = (w_1, ..., w_k; \mu_1, ..., \mu_k; \Sigma_1, ..., \Sigma_k)</math> — параметры смеси гауссовых распределений; <math>Y</math> — матрица размера <math>n \times k</math> с вероятностями членства в кластерах.

'''Объем выходных данных''': <math>k(n + q^2 + q + 1)</math>.

=== Свойства алгоритма ===
Алгоритм является ''недетерминированным''. Число итераций до сходимости метода зависит от начального приближения и выбранного критерия останова.

Предположим, что размерность элементов выборки <math>q</math> и число кластеров <math>k</math> значительно меньше числа элементов выборки <math>n</math> (<math>k \ll n, q \ll n</math>), а число итераций до сходимости метода равно <math>m</math>. Тогда вычислительная мощность алгоритма, как отношение числа операций к суммарному объему входных и выходных данных, имеет порядок <math>O\bigg(\frac{kq^2}{q + k}m\bigg)</math>.
==== Достоинства и недостатки алгоритма ====
Среди достоинств EM-алгоритма можно выделить следующие:
* Мощная статистическая основа.
* Линейное увеличение сложности при росте объема данных.
* Устойчивость к шумам и пропускам в данных.
* Возможность построения желаемого числа кластеров.
* Быстрая сходимость при удачной инициализации.
К недостаткам EM-алгоритма можно отнести следующее:
* Алгоритм неустойчив по начальным данным (то есть тем, которые инициализируют вектор параметров на первой итерации), так как он находит локальный экстремум, значение которого может оказаться гораздо ниже, чем глобальный максимум. В зависимости от выбора начального приближения алгоритм может сходиться к разным точкам. Также может сильно варьироваться скорость сходимости.
* Алгоритм не позволяет определять количество <math>k</math> компонент смеси. Эта величина является структурным параметром алгоритма.
* Предположение о нормальности всех измерений данных не всегда выполняется.

== Программная реализация алгоритма ==

=== Особенности реализации последовательного алгоритма ===

=== Локальность данных и вычислений ===

=== Возможные способы и особенности параллельной реализации алгоритма ===

=== Масштабируемость алгоритма и его реализации ===

==== Масштабируемость алгоритма ====

==== Масштабируемость реализации алгоритма ====

Для исследования масштабируемости EM-алгоритм кластеризации был реализован с помощью технологии MPI. Была реализована версия алгоритма с диагональными матрицами ковариации. В качестве критерия останова было выбрано достижение максимального числа итераций (соответственно, вычисление логарифмического правдоподобия на каждой итерации не проводится).

Алгоритм параллельной реализации:
# Распределение элементов выборки. Процесс 0 распределяет поровну элементы выборки по остальным процессам.
# Инициализация параметров смеси гауссовых распределений. Процесс 0 инициализирует параметры и отправляет их остальным процессам. <math>\mu_j</math> инициализируются случайными значениями в отрезке <math>[-1, 1]</math>, ковариационные матрицы <math>\Sigma_j</math> определяются как единичные, веса <math>w_i</math> кластеров задаются равными <math>\frac{1}{k}</math>.
# Выполнение E-шага и M-шага алгоритма до достижения максимального числа итераций.
## E-шаг. Каждый процесс вычисляет значения скрытых переменных <math>y_{ij}</math> по своему набору элементов выборки.
## M-шаг.
### Каждый процесс вычисляет суммы значений скрытых переменных <math>\sum_{i = 1}^{n\_proc_i}y_{ij}</math> для каждого кластера <math>j = \overline{1, k}</math> по своему набору элементов выборки и отправляет полученные суммы процессу 0. Процесс 0 вычисляет значения <math>n_j</math> по полученным суммам и отправляет их остальным процессам. Каждый процесс обновляет значения <math>w_j</math> по полученным значениям <math>n_j</math>.
### Каждый процесс вычисляет суммы <math>\sum_{i = 1}^{n\_proc_i}y_{ij}x_i</math> для каждого кластера <math>j = \overline{1, k}</math> по своему набору элементов выборки и отправляет полученные суммы процессу 0. Процесс 0 вычисляет суммы <math>\sum_{i = 1}^{n}y_{ij}x_i</math> для каждого кластера <math>j = \overline{1, k}</math> по всем элементам выборки и отправляет их остальным процессам. С помощью полученных сумм каждый процесс вычисляет значения математических ожиданий <math>\mu_j</math>.
### Каждый процесс вычисляет суммы <math>sum_l = \sum_{i = 1}^{n\_proc_i}y_{ij}(x_{il} - \mu_{jl}^{new})^2 \, (l = \overline{1, q})</math> для каждого кластера <math>j = \overline{1, k}</math> по своему набору элементов выборки и отправляет полученные суммы процессу 0. Процесс 0 вычисляет суммы <math>sum_l = \sum_{i = 1}^{n}y_{ij}(x_{il} - \mu_{jl}^{new})^2 \, (l = \overline{1, q})</math> для каждого кластера <math>j = \overline{1, k}</math> по всем элементам выборки и отправляет их остальным процессам. С помощью полученных сумм каждый процесс вычисляет значения диагональных элементов матриц ковариации <math>\Sigma_j</math>.

Распараллеливание было проведено по числу элементов выборки, поэтому и исследование масштабируемости было проведено для числа элементов выборки. Исследование проводилось на суперкомпьютере "Ломоносов"<ref name="Lom">Воеводин Вл., Жуматий С., Соболев С., Антонов А., Брызгалов П., Никитенко Д., Стефанов К., Воеводин Вад. Практика суперкомпьютера «Ломоносов» // Открытые системы, 2012, N 7, С. 36-39.</ref> [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета].

Набор и границы значений изменяемых параметров запуска реализации алгоритма:
* число процессов [8 : 128] с шагом 8;
* число элементов выборки [1000000 : 20000000] с шагом 1000000;
* размерность элементов выборки 4;
* число кластеров 4;
* число итераций 50.

Для каждого набора параметров измерялось среднее время выполнения одной итерации алгоритма. На следующем рисунке приведен график производительности данной реализации EM-алгоритма кластеризации в зависимости от изменяемых параметров запуска.

[[Файл:Em-performance-Lavrushkin.png|thumb|1650px|center|Рисунок 8. Параллельная реализация EM-алгоритма кластеризации. Изменение производительности в зависимости от числа процессов и числа элементов выборки.]]

[https://github.com/HighVoltageRocknRoll/EM-clusterization_scalability Исследованная параллельная MPI-реализация на языке C]

=== Динамические характеристики и эффективность реализации алгоритма ===

=== Выводы для классов архитектур ===

=== Существующие реализации алгоритма ===
# [http://docs.opencv.org/2.4/modules/ml/doc/expectation_maximization.html OpenCV];
# [http://arma.sourceforge.net/docs.html#gmm_diag Armadillo] — OpenMP реализация с предположением диагональности ковариационных матриц;
# [http://www.mlpack.org/docs/mlpack-git/doxygen.php?doc=classmlpack_1_1gmm_1_1GMM.html MLPack];
# [http://scikit-learn.org/stable/modules/mixture.html scikit-learn];
# [http://www.mathworks.com/help/stats/clustering-using-gaussian-mixture-models.html Matlab];
# [https://github.com/Corv/CUDA-GMM-MultiGPU CUDA реализация №1];
# [http://andrewharp.com/gmmcuda CUDA реализация №2].

== Литература ==
<references \>

Обсуждение участника:Sergey Lavrushkin

2016-11-16T13:04:46Z

Algoman:

== Замечания к [[Участник:Sergey_Lavrushkin/EM-алгоритм_кластеризации]] ==

1) отсутствует оценка ширины ЯПФ параллельного алгоритма во врезке в начале статьи

2) отсутствует оценка вычислительной мощности алгоритма в п 1.10

3) пункты 2.1 и 2.2 должны быть 2.4 и 2.7, согласно формату описания [[Структура_описания_свойств_алгоритмов]]

4) '''Далее - правки с нового этапа проверки.''' Проверьте орфографию. Обнаружил, например, загадочное слово "единчиные"

5) Нет ссылок на источники из списка литературы

6) В п 1.2 отдельно выделите, что такое параметр q - он участвует в оценках во врезке, нужно дать возможность читателю быстро найти, что это

7) "В случае смести гауссовых распределений предполагается, что все компоненты имеют многомерное нормальное распределение" - гауссово распределение и есть нормальное. Лучше использовать только "гауссово", или только "нормальное", чтоб людей не путать

8) "То есть в случае q-мерного пространства признаков..." - формулу для сигмы квадрат лучше перенести в соотв. пункт списка после слова "где", а в скобках указать, что его еще называют расстоянием Махаланобиса

== Замечания к пункту 2.4 от 16.11.2016 ==

* какие выводы можно сделать о масштабируемости алгоритма, исходя из полученных данных? Требуется явно написать это в пункте.
* текст с особенностями паралелльной реализации лучше перенести в пункт 2.3

Участник:MelLain/ЕМ-алгоритм (Тематическое моделирование)

2016-11-16T12:57:50Z

Algoman:

{{Assignment|Algoman}}
Статью подготовили:

* [[U:MelLain|Мурат Апишев]] (реализация кода, описание теоретической части и деталей реализации);
* [[U:Заночкин Андрей|Андрей Заночкин]] (реализация кода, информационный граф, оценки сложности и экспериментальная часть).

= ЧАСТЬ. Свойства и структура алгоритмов =

== Общее описание алгоритма ==

'''Тематическое моделирование'''<ref>https://ru.wikipedia.org/wiki/Тематическое_моделирование</ref><ref>http://www.machinelearning.ru/wiki/index.php?title=Тематическое_моделирование</ref> - одно из направлений статистического анализа текстовых коллекций в машинном обучении. В литературе описываются многочисленные разновидности моделей, а также методов их обучения. В данной статье будет рассмотрена тематическая модель ''вероятностного латентного семантического анализа''<ref>https://en.wikipedia.org/wiki/Probabilistic_latent_semantic_analysis</ref> (PLSA), и процесс её обучения с помощью параллельного ЕМ-алгоритма.

Существует множество разновидностей ЕМ-алгоритмов, ориентированных на учёт тех или иные аспектов решаемой задачи. Наиболее простым вариантом является т.н. ''оффлайновый'' алгоритм, непригодный для работы с большими текстовыми данными в силу значительных требований к потребляемой оперативной памяти. Существует ряд модернизаций этого алгоритма, позволяющих избавить его от ряда недостатков. Наилучшей из них является ''онлайновый'' вариант алгоритма. Тем не менее, в силу относительно высокой сложности его эффективной параллельной реализации, в данной статье будет рассматриваться гибридный вариант алгоритма, избавленный от большинства недостатков оффлайнового, но имеющий меньшую скорость сходимости, чем онлайновый.

== Математическое описание алгоритма ==

=== Математическое описание модели ===

В большинстве тематических моделей коллекция текстов рассматривается в виде "мешка слов", т.е. модель учитывает только статистическую встречаемость слов в документах и никак не использует информацию об их взаимном расположении внутри документа.

Вероятностная модель PLSA имеет следующий вид:

:<math>
\begin{align}
F \approx \Phi \times \Theta
\end{align}
</math>

Здесь <math>F</math> - это матрица исходных данных размера <math>|W| \times |D|</math>, где <math>D</math> - это множество документов, а <math>W</math> - словарь коллекции, т.е. множество всех уникальных слов, встретившихся в документах.

<math>\Phi</math> - это матрица параметров модели размера <math>|W| \times |T|</math>, где <math>T</math> - это множество тем, которые мы хотим извлечь из коллекции. Под темой в бытовом смысле смысле понимается набор слов, характеризующих её. Формально говоря, тема - это вероятностное распределение на множестве слов <math>W</math>, поэтому матрица <math>\Phi</math> является стохастической, т.е. столбцы её неотрицательны и суммируются в единицу.

<math>\Theta</math> - матрица результатов кластеризации обучающей коллекции по полученным темам размера <math>|T| \times |D|</math>, в ней столбцы также являются вероятностными распределениями, на этот раз документов на множестве тем.

Фактически, PLSA есть ни что иное, как задача приближённого стохастического матричного разложения, в ходе которой производится мягкая бикластеризация данных (мягкая - потому что объекты распределяются по классам не строго, а с некоторой вероятностью, би - потому что производится одновременная кластрезация слов по темам, и тем - по документам). Поставленную задачу можно решать методом максимального правдоподобия, с помощью ЕМ-алгоритма.

В данной статье будут расматриваться только плотные матрицы (хотя при определённых условиях можно эффективно использовать разреженные).

=== Математическое описание ЕМ-алгоритма ===

Задача максимизации логарифма правдоподобия для описанной модели имеет следующий вид:

:<math>
\begin{align}
\mathcal{L}(\Phi, \Theta) = \sum_{d \in D}\sum_{w \in d} n_{dw} \,\mathrm{ln}(\sum_{t \in T} \phi_{wt} \theta_{td}) \rightarrow \underset{\Phi, \Theta}{\mathrm{max}}
\end{align}
</math>

:<math>
\begin{align}
\sum_{w \in W} \phi_{wt} = 1, \, \forall t \in T, \quad \phi_{wt} \ge 0;
\end{align}
</math>

:<math>
\begin{align}
\sum_{t \in T} \theta_{td} = 1, \, \forall d \in D, \quad \theta_{td} \ge 0.
\end{align}
</math>

Прямая оптимизация логарифма правдоподобия - очень сложная задача, поэтому её решают приближённо с помощью метода простых итераций, в котором чередуются два шага: E (expectation) и M (maximization). Перед первой итерацией выбираются начальные приближения параметров <math>\Phi</math> и <math>\Theta</math>.

На Е-шаге по текущим значениям параметров с помощью формулы Байеса вычисляются вспомогательные переменные - условные вероятности <math>p(t\, | \,d, \,w)</math> для всех тем <math>t \in T</math>, для каждого термина <math>w \in d</math> для каждого документа <math>d \in D</math>:

:<math>
\begin{align}
p(t\, | \,d, \,w ) = \cfrac{\phi_{wt}\theta_{td}}{\sum_{s \in T}\phi_{ws}\theta_{sd}}
\end{align}
</math>

На М-шаге, наоброт, по условным вероятностям <math>p(t\, | \,d, \,w)</math> вычисляется новое приближение параметров <math>\phi_{wt}</math>, <math>\theta_{td}</math>:

:<math>
\begin{align}
\phi_{wt} = \cfrac{\hat n_{wt}}{\hat n_t}, \quad \hat n_t = \sum_{w \in W} \hat n_{wt}, \quad \hat n_{wt} = \sum_{d \in D} n_{dw} p(t\, | \,d, \,w )
\end{align}
</math>

:<math>
\begin{align}
\theta_{td} = \cfrac{\hat n_{dt}}{\hat n_d}, \quad \hat n_d = \sum_{t \in T} \hat n_{dt}, \quad \hat n_{dt} = \sum_{w \in d} n_{dw} p(t\, | \,d, \,w )
\end{align}
</math>

Строгое обоснование данных формул можно получить с помощью теоремы Куна-Таккера.

=== Общие слова о модернизациях ===

Как уже было сказано, и как видно из описания выше, данный алгоритм сложно применять на практике в чистом виде из-за необходимости хранения трёхмерной матрицы <math>p(t\, | \,d, \,w)</math> и двумерной матрицы <math>\Theta</math>, размеры которых зависят от количества обрабатываемых и данных, которых может быть очень много.

Для борьбы с описанной проблемой можно производить вычисления более рационально, отказавшись от хранения обеих матриц и вычисляя необходимы значения на лету. При наличии обученной модели <math>\Phi</math> получить векторы распределений <math>\theta_d</math> (если в этом есть необходимость) можно, произведя одну итерацию алгоритма, в ходе которой сама модель обновляться не будет.

В этом варианте алгоритма вычисление <math>\theta_d</math> будет перенесено с М-шага на Е-шаг, и для каждого нового документа этот вектор будет инициализирован равномерным распределением. Для ускорения скорости сходимости можно производить итерации "пересчёт <math>p(t\, | \,d, \,w)</math>" - "обновление <math>\theta_d</math>" многократно в течении обработки одного документа.

В дальнейшем подобные итерации будем называть "внутренними", полный же однократный проход по всей коллекции будем называть итерацией "внешней".

== Вычислительное ядро алгоритма ==

Наиболее вычислительно затратной операцией в данном алгоритме является Е-шаг, в ходе которого рассчитываются вспомогательные переменные и векторы <math>\theta_d</math>. С введением внутренних итераций нагрузка на Е-шаг только увеличивается.

== Макроструктура алгоритма ==

В целом, высокоуровневое описание ЕМ-алгоритма состоит из самих Е-шага и М-шага, что можно видеть на нижеприведённом листинге.

== Схема реализации последовательного алгоритма ==

Приведём здесь листинг описываемого алгоритма:
<source lang="...">
1. Инициализировать phi_wt^0 для всех w из W, t из T;

2. Внешняя итерация по коллекции i = 1 ... num_outer_iter:

3. n_wt^i := 0, n_t^i := 0 для всех w из W и t из T;

4. Цикл по документам d из D:

5. Инициализировать вектор theta_d^0 для всех t из T и Z_w^0, для всех w из d;

6. Внутренняя итерация по документу j = 1 ... num_inner_iter:

7. Z_w^j := сумме по всем t из T (phi_wt^(i-1) * theta_td^(j-1)), для всех w из d;

8. theta_td^j := (1 / n_d) * на сумму по всем w из d (n_dw * phi_wt^(i-1) * theta_td^(j-1) / Z_w^j), для всех t из T;

9. Увеличить n_wt^i и n_t^i на (n_dw * phi_wt^(i-1) * theta_td / Z_w), для всех w из W и t из T;

10. phi_wt^i := (n_wt^i / n_t^i), для всех w из W и t из T

Здесь Z_w - это сумма всех p(t| d, w) для данного документа, нормировочная константа.
</source>

== Последовательная сложность алгоритма ==

Рассмотрим ЕМ-алгоритм с <math>num\_outer\_iter</math> внешними итерациями и <math>num\_inner\_iter</math> внутренними применительно к набору документов <math>D</math> и слов <math>W</math>, классифицирующий коллекцию по темам <math>T</math>.

Так на каждой внутренней итерации производится

* умножений: <math>|W|\cdot|T| + 2|T|\cdot|D|</math> ,
* делений : <math>|T|\cdot(|D| + 1)</math>,
* сложений: <math>|W|\cdot(|T|-1) + |T|\cdot(|D| - 1)</math>.

А значит на одной внешней итерации производится

* умножений: <math>(|W|\cdot|T| + 2|T|\cdot|D|)\cdot num\_inner\_iter \cdot |D|</math> ,
* делений : <math>|T|\cdot(|D| + 1)\cdot num\_inner\_iter \cdot |D| + |W|\cdot|T|</math> ,
* сложений: <math>\Big(\big[|W|\cdot(|T|-1) + |T|\cdot(|D| - 1)\big]\cdot num\_inner\_iter + |W|\cdot|T|\Big)\cdot |D|</math> .

Соответственно для всего алгоритма каждая из этих операций повторяется <math>num\_outer\_iter</math> раз. Наиболее часто выполняется операция умножения, однако порядок величин одинаковый. Разница будет заметна лишь в том случае, когда <math>|D|</math> имеет меньший порядок, чем <math>|W|</math>. В этом случае делений будет значительно меньше, чем сложений и умножений.

По классификации по последовательной сложности ЕМ-алгоритм можно отнести к ''линейным'' по <math>num\_inner\_iter, num\_outer\_iter , |T|, |W|</math>, а попеременной <math>|D|</math> - ''с квадратичной сложностью''.

== Информационный граф ==

Опишем [[глоссарий#Граф алгоритма|граф алгоритма]]<ref>Воеводин В.В. Математические основы параллельных вычислений// М.: Изд. Моск. ун-та, 1991. 345 с.</ref><ref>Воеводин В.В., Воеводин Вл.В. Параллельные вычисления. – СПб.: БХВ - Петербург, 2002. – 608 с.</ref><ref>Фролов А.В.. Принципы построения и описание языка Сигма. Препринт ОВМ АН N 236. М.: ОВМ АН СССР, 1989.</ref> как аналитически, так и в виде рисунка.

[[Файл:EM-temat inner1.png|thumb|left|200px|Рисунок 1. Граф алгоритма внутренней итерации. Рассмотрено две итерации цикла.]]
'''Первый''' граф описывает алгоритм внутреннего цикла.
[[Файл:EM-temat doc.png|thumb|right|400px|Рисунок 2. Граф алгоритма анализа документа]]
[[Файл:EM-temat outer.png|thumb|right|400px|Рисунок 3. Граф алгоритма внешней итерации. Рассмотрен случай трех внешних итераций, при трех рассматриваемых документах]]

В качестве входных параметров выступают
* вектор <math>\theta_{init} </math>, инициализированный значениями <math>1/|T|</math>, длиной <math>|T|</math>,
* матрица <math>\Phi</math>, размера <math>|W|\times |T|</math>,
* вектор <math>n</math>, длины <math>|W|</math>.

В качестве выходных параметров выступают
* вектор <math>\theta</math>, длиной <math>|T|</math>,
* вектор <math>nZ</math>, длиной <math>|W|</math>.

Внутри алгоритма используются элементарные операции
* Умножения матрицы на вектор <math>M \cdot V</math>,
* Поэлементного умножения вектора на вектор <math>V. \cdot V</math>,
* Поэлементного деления вектора на вектор <math>U. \cdot V</math>.

Данные операции были рассмотрены в [https://algowiki-project.org/ru/%D0%A1%D1%83%D0%BC%D0%BC%D0%B0_%D0%B2%D0%B5%D0%BA%D1%82%D0%BE%D1%80%D0%B0_%D0%B8_%D0%BF%D1%80%D0%BE%D0%B8%D0%B7%D0%B2%D0%B5%D0%B4%D0%B5%D0%BD%D0%B8%D1%8F_%D0%BC%D0%B0%D1%82%D1%80%D0%B8%D1%86%D1%8B_%D0%BD%D0%B0_%D0%B4%D1%80%D1%83%D0%B3%D0%BE%D0%B9_%D0%B2%D0%B5%D0%BA%D1%82%D0%BE%D1%80,_%D0%B2%D0%B5%D1%89%D0%B5%D1%81%D1%82%D0%B2%D0%B5%D0%BD%D0%BD%D0%B0%D1%8F_%D0%B2%D0%B5%D1%80%D1%81%D0%B8%D1%8F,_%D0%BF%D0%BE%D1%81%D0%BB%D0%B5%D0%B4%D0%BE%D0%B2%D0%B0%D1%82%D0%B5%D0%BB%D1%8C%D0%BD%D1%8B%D0%B9_%D0%B2%D0%B0%D1%80%D0%B8%D0%B0%D0%BD%D1%82,_%D0%BF%D0%BB%D0%BE%D1%82%D0%BD%D0%B0%D1%8F_%D0%BC%D0%B0%D1%82%D1%80%D0%B8%D1%86%D0%B0 соответствующей статье], поэтому не будем останавливаться отдельно на каждой из них.

'''Второй''' граф описывает Е-шаг алгоритма при анализе отдельного документа.

В качестве входных параметров выступают
* матрица <math>\Phi</math>, размера <math>|W|\times |T|</math>,
* вектор <math>n</math>, длины <math>|W|</math>.

В качестве выходных параметров выступают
* матрица <math>N</math>, размера <math>|W|\times |T|</math>.

Внутри алгоритма используются элементарные операции
* Суммирования элементов вектора <math>\Sigma</math>,
* Поэлементного деления вектора на скаляр <math>V / c</math>,
* Поэлементного умножения вектора на скаляр <math>V \cdot c</math>,
* Умножения строк матрицы на элементы вектора <math>M. \cdot V</math>,
* Умножения столбцов матрицы на элементы вектора <math>V. \cdot M</math>.

А также используется операция <math>inner</math>, описанная на предыдущем шаге.

'''Третий''' граф описывает алгоритм внешнего цикла.

В качестве входных параметров выступают
* Нулевая матрица, размера <math>|W|\times |T|</math>,
* матрица <math>\Phi_0</math>, размера <math>|W|\times |T|</math>,
* Набор векторов <math>n(d_i)</math>, длины <math>|W|</math>, являющихся столбцами матрицы <math>n_{wd}</math>.

В качестве выходных параметров выступают
* вектор <math>\theta_{num\_outer\_iter}</math>, длиной <math>|T|</math>.

Внутри алгоритма используются элементарные операции
* Суммы двух матриц ,
* Суммы элементов столбцов матрицы <math>\Sigma M</math>,
* Деления столбцов матрицы на элементы вектора <math>M./ V</math>.

А также используется операция <math>Doc</math>, описанная на втором шаге.

== Ресурс параллелизма алгоритма ==

Е-шаг представляет собой наиболее подходящее место в алгоритме для применения параллелизма. Во-первых, потому, что является наиболее ресурсоёмким этапом, во-вторых - потому что в нём производится итерирование по документам коллекции, при этом обработка каждого документа выполняется фактически независимо.

Параллелить также можно и М-шаг, но в данной статье это не будет рассматриваться за ненадобностью. В практических реализациях это делается крайне редко.

== Входные и выходные данные алгоритма ==

Если рассматривать EM-алгоритм на прикладном уровне, то в качестве входных параметров выступает коллекция документов <math>D</math>, которая предварительно анализируется и порождает множество слов <math>W</math>. Также к входным данным относится количество тем <math>T</math>. Поскольку анализ документов и выделение слов являются отдельной задачей, то мы будем полагать, что на вход подаются оцифрованные данные в следующем виде:

'''Входные данные''':
* матрица частот <math>n_{dw}</math>, отвечающая количеству слов <math>w</math>, встречающихся в документе <math>d</math>. По определению элементы этой матрицы могут принимать лишь неотрицательные ''целые'' значения.
* пара параметров <math>num\_outer\_iter, num\_inner\_iter</math> и количество тем <math>|T|</math>. Эти величины могут быть только положительными целыми числами.

'''Объём входных данных''':
* Матрица частот размером <math>|W|\times |D|</math>, а также три скалярные константы.

'''Выходные данные''':
* Матрица модели <math>\Phi</math>, то есть распределений слов в полученных темах (если добавить кэширование матрицы <math>\Theta</math>, то можно сразу получить и её, хотя это скажется на объёме потребляемой памяти).

'''Объём выходных данных''':
* <math>|W|\times|T| \big(+ |T|\times|D| \big)</math>.

== Свойства алгоритма ==

С вычислительной точки зрения алгоритм является детерминированным, в силу фиксированного взаимного размещения данных в памяти. Масштабируемость параллельной реализации может зависеть от ряда факторов, которые будут рассмотрены далее.

С точки зрения результата работы алгоритм детерминированным не является, он неустойчив, имеет тенденцию к попаданию в локальные минимумы. Результат работы сильно зависит от начального приближения, которое, как правило, выбирается случайным образом.

Вычислительная мощность алгоритма равна отношению числа операций к суммарному объему входных и выходных данных. Она показывает, сколько операций приходится на единицу переданных данных.

Суммарное количество входных параметров можно читать равным <math>|W|\times|D| </math>

Суммарное количество выходных параметров в точности равно <math>|W|\times|T| (+ |T|\times |D|) </math>

Количество операций при больших значениях параметров <math>num\_outer\_iter</math> и <math>num\_inner\_iter</math> можно считать равным
<math>(2|W|\cdot|T| + 4|T|\cdot|D|)\cdot |D| \cdot num\_inner\_iter \cdot num\_outer\_iter</math>

Итак вычислительная сложность алгоритма равна
<math>\frac{(2|W|\cdot|T| + 4|T|\cdot|D|)\cdot |D|}{|W|\cdot|D| + |W|\cdot|T| (+ |T|\cdot |D|)} \cdot num\_inner\_iter \cdot num\_outer\_iter</math>

Очевидно, что по параметрам итерации вычислительная сложность линейна. Более сложная зависимость наблюдается по параметрам количества тем, слов и документов. Наибольший интерес представляет зависимость сложности от количества документов, поскольку на практике именно этот параметр имеет больший порядок, нежели остальные значения. Так асимптотически алгоритм имеет линейную сложность по этому параметру. По остальным же параметрам вычислительная сложность ограничена некоторой константой, которая зависит от других параметров и может быть легко получена взятием предела выражения по соответствующим переменным.

= ЧАСТЬ. Программная реализация алгоритма =

== Особенности реализации последовательного алгоритма ==

В простейшем варианте (без внутренних итераций по <math>\theta_d</math> и с хранением всех этих векторов) алгоритм без применения параллелизма и векторизации на языке Python выглядит следующим образом:

<source lang="python">
# Author: Murat Apishev (great-mel@yandex.ru)

def plsa_em(n_dw, num_topics, max_outer_iter, Phi_init, Theta_init):
num_tokens, num_docs = n_dw.shape
Phi = Phi_init if not Phi_init is None else init_matrix(num_tokens, num_topics)
Theta = Theta_init if not Theta_init is None else init_matrix(num_topics, num_docs)

for i in xrange(max_outer_iter):
time_start = time.time()
n_wt = np.zeros([num_tokens, num_topics]);
n_t = [0] * num_topics
Theta_new = np.array(Theta)

for d in xrange(num_docs):
Z_w = [0] * num_tokens
for w in xrange(num_tokens):
z_w = 0.0
for t in xrange(num_topics):
z_w += Phi[w, t] * Theta[t, d]
Z_w[w] = z_w

for t in xrange(num_topics):
value = 0.0
for w in xrange(num_tokens):
if Z_w[w] < EPS:
continue

value += n_dw[w, d] * Phi[w, t] * Theta[t, d] / Z_w[w]

denominator = np.sum(n_dw[:, d])
if denominator < EPS:
continue

Theta_new[t, d] = 1.0 / np.sum(n_dw[:, d]) * value

for w in xrange(num_tokens):
for t in xrange(num_topics):
if Z_w[w] < EPS:
continue

value = n_dw[w, d] * Phi[w, t] * Theta[t, d] / Z_w[w]
n_wt[w, t] += value
n_t[t] += value

Phi = n_wt / n_t
Theta = Theta_new
return Phi, Theta
</source>

== Локальность данных и вычислений ==

В параллельной реализации присутствует локальность данных. Основным разделяемым ресурсом для потоков-обработчиков является матрицы <math>n_{wt}</math> и <math>\Phi</math>. Они хранятся в виде хэш-таблиц, где ключом является слово, а значением - вектор, длинной в число тем. В силу последовательного хранения данных вектором, производится эффективное итерирование в циклах по темам.

== Возможные способы и особенности параллельной реализации алгоритма ==

Вне зависимости от того, каким образом производить параллельную/распределённую обработку коллекции, основным способом увеличения производительности является разделение обработки отдельных документов. Существующие архитектуры алгоритмов тематического моделирования (не только на основе описанного ЕМ-алгоритма) на MPI, Hadoop MapReduce, Spark, а также параллельные архитектуры на одиночных машинах, работают в рамках одной этой парадигмы.

Как уже было отмечено, в описанном алгоритме большая часть вычислений приходится на Е-шаг (в некоторых экспериментах он занимал более 99% времени работы). Поэтому именно он был выбран в качестве объекта для реализации параллелизма. Общую схему можно описать следующим образом. Вместо того, чтобы обрабатывать документы в цикле последовательно, можно делать это параллельно, поскольку для описанного алгоритма обработка разных документов являются независимыми операциями. Таким образом, входные данные, то есть документы, разбиваются на пакеты, в каждом из которых находится фиксированное количество документов, каждый пакет сохраняется на диск в виде отдельного файла, все файлы хранятся в одной директории, подаваемой на вход алгоритму.

Далее алгоритм перед началом очередной итерации прохода по коллекции просматривает рабочую директорию и сохраняет в специальную очередь имена файлов с документами. Перед началом каждой итерации производится создание нескольких параллельных потоков-обработчиков, каждый из которых занимается вычислением Е-шага. Для этого каждый обработчик, не занятый в текущий момент времени, проверяет очередь с именами файлов на наличие в ней необработанных пакетов, и, в случае присутствия таких, извлекает очередное имя файла, открывает сам файл и последовательно обрабатывает все находящиеся в нём документы. Имя обрабатываемого файла из очереди удаляется. Итерация заканчивается тогда, когда все обработчики завершили свою работу. На этом параллельный Е-шаг завершается, алгоритм производит последовательный М-шаг, и либо завершается, либо начинает новую внешнюю итерацию.

Ключевым моментом организации распараллеливания в среде с разделяемой памятью (а здесь она именно такая) является организация доступа различных потоков к разделяемым ресурсам. В силу ручной реализации потоков (без использования OpenMP) решение проблемы ложится на авторов кода. Как было отмечено выше, разделяемыми ресурсами являются две матрицы размера "число слов" на "число тем". Обе они имеют фиксированные размеры всё время работы алгоритма. Как было сказано, обе матрицы реализованы в виде хэш-таблиц с ключами-словами. Единицей блокировки является вектор, соответствующий одному слову. Для организации такого доступа каждая матрица хранит вектор объектов mutex, по одному на каждый ключ матрицы, и имеет методы, регулирующие, с помощью этих mutex-ов, доступ к каждой строке.

Очередь имён файлов также имеет mutex, поскольку используется всеми потоками.

== Масштабируемость алгоритма и его реализации ==

Данная параллельная реализация тестировалась на компьютере со вычислительными следующими характеристиками:

Intel(R) Core(TM) i7-5820K @ 3.30GHz (6 физических ядер, 12 потоков, без использования аппаратного ускорения ядер).

Соответственно, максимальное количество параллельных обработчиков было равно 12. В качестве входных данных использовалась коллекция писем [https://www.kaggle.com/kaggle/hillary-clinton-emails/downloads/hillary-clinton-emails-release-2015-09-11-01-39-01.zip Х. Клинтон] (точнее, её подмножество из 6000 тысяч писем, т. е. больше 80%). Вся коллекция, как было отмечено выше, делится на текстовые файлы, в каждом файле одна строка соответствует одному документу. Единицей параллелизма является файл.

Измеряемыми параметрами масштабируемости являются:

* количество тем;
* количество внутренних итераций;
* количество потоков-обработчиков.

Количество документов в каждом пакете зафиксируем равным 100. Число внешних итераций - 10.

Измеряемым параметром является время работы алгоритма без учёта вспомогательных операций (сбор словаря коллекции, который реализация умеет производить однократно и далее переиспользовать сохранённый на диск результат). Для каждого фиксированного числа тем и количества внутренних итераций построен двумерный график зависимости времени работы от числа потоков, т.е. график масштабируемости алгоритма.

[[file:PlsaEm.png|thumb|center|900px|Рисунок 4. Масштабируемость ЕМ-алгоритма для тематического моделирования. Столбцы соответствуют различному числу тем (слева направо 10, 20 и 40). Строки - числу внутренних итераций (сверху вниз 1, 5 и 10). Синие линии соответствуют времени работы алгоритма при различных значениях количества потоков (ось Х каждого графика), красные - идеальному масштабированию.]]

Можно заметить, что качество параллелизма постоянно растёт с увеличением нагрузки на Е-шаг, что является признаком качественной архитектуры. Вывод сделан потому, что и увеличение объёма обрабатываемых данных, и ускорение скорости сходимости модели, и увеличение числа тем - всё это является основными источниками увеличения вычислительных затрат при работе алгоритма. Получается, что алгоритм при усложнении обрабатываемой задачи показывает всё более хорошую масштабируемость. В качестве примера рассматриватся в разы усложнённая задача: 200 тем и 20 внутренних итераций на той же коллекции текстов:

[[file:PlsaEmHard.png|thumb|center|500px|Рисунок 5. Масштабируемость ЕМ-алгоритма для тематического моделирования в сложном случае. Обозначения аналогичны рис 4.]]

[https://github.com/MelLain/study/tree/master/C%2B%2B/Parallel-EM Реализация алгоритма на языке C++ (STL, Boost)]

== Динамические характеристики и эффективность реализации алгоритма ==

== Выводы для классов архитектур ==

== Существующие реализации алгоритма ==

Наиболее близкой (хотя далеко не идентичной) реализацией описанного алгоритма является ЕМ-алгоритм для тематического моделирования из библиотеки [http://www.bigartm.org BigARTM]. Там реализован полноценный онлайновый ЕМ-алгоритм с относительно сложной архитектурой распараллеливания, позволяющий добиться эффективной онлайновой обработки огромных текстовых коллекций на одной машине.

Существуют и другие программные реализации алгоритмов для тематического моделирования, но большинство из них не использует ЕМ-алгоритм, или же использует его вариационный вариант, который здесь не рассматривается (хотя идеи параллелизма там используются схожие).

= Литература =
<references />

[[Категория:Незаконченные статьи]]
[[Категория:ЕМ-алгоритм]]

Участник:Мария Готман/Алгоритм кластеризации, основанный на максимизации ожидания

2016-11-16T11:24:17Z

Algoman:

Авторы описания: [[Участник:Мария_Готман|Готман М.Л.]], [[Участник:Julia_lukashkina|Лукашкина Ю.Н.]]

= ЧАСТЬ. Свойства и структура алгоритмов =
== Общее описание алгоритма ==
Задача кластеризации — это задача разбиения заданной входной выборки объектов на непересекающиеся подмножества, называемые кластерами, так, чтобы каждый кластер состоял из схожих объектов, а объекты разных кластеров существенно отличались.

Для решения этой задачи можно использовать, например, метод максимизации ожидания, также известный как EM-алгоритм (англ. expectation-maximization) <ref>Воронцов К.В.; Математические методы обучения по прецедентам (теория обучения машин)</ref>. В таком случае делается предположение, что входные данные — смесь многомерных нормальных распределений, соотвественно отдельный кластер — это одна компонента смеси. Предполагается, что количество кластеров является входным параметром алгоритма (существуют модификации EM-алгоритма, которые автоматически находят число кластеров, но они не рассматриваются в данной статье). Результат работы EM-алгоритма — веса кластеров и найденные параметры нормальных распределений для каждого кластера: вектора математических ожиданий и матрицы ковариации.

Алгоритм EM кластеризации основан на итеративном выполнении двух последовательных шагов: E-шага и M-шага. На E-шаге вычисляются вспомогательные (скрытые) переменные, которые характеризуют апостериорную вероятность того, что определенный обучающий объект получен из фиксированной компоненты смеси. На M-шаге с помощью вычисленных скрытых переменных производится обновление параметров смеси: по определённым формулам пересчитываются веса кластеров, их математические ожидания и матрицы ковариаций.

Стоит отметить, что на работу EM-алгоритма значительно влияет начальное приближение его параметров. При неудачной инициализации алгоритм может не сойтись или сойтись в локальный экстремум.

В данной статье рассматривается частный случай EM-алгоритма, который работает с двумерными входными данными.

[[Файл:Em clusters 4.png|400px|thumb|center|Пример работы EM-алгоритма для 5ти кластеров.]]

== Математическое описание алгоритма ==
Рассматривается смесь многомерных нормальных распределений <math>p_j(x) = N(x;\mu_j, \Sigma_j) = \frac1{(2\pi)^{d/2}\sqrt{|\Sigma_j|}} \exp \biggl(-\frac{1}{2}(x - \mu_j) \Sigma_j^{-1} (x - \mu_j)^T\biggr) </math> с весами <math>w_j</math>: <math>p(x)=\sum_{j=1}^kw_jp_j(x), \sum_{j=1}^kw_j =1, w_j \ge 0</math>.

На вход алгоритму подаются <math>m </math> объектов, каждый из которых имеет <math>d</math> признаков, в виде матрицы объектов-признаков <math>X \in \R^{m \times d}</math> и <math>k</math> — количество кластеров.

Алгоритм кластеризации, основанный на максимизации правдоподобия, итеративно выполняет два шага: E-шаг и M-шаг.
Идея алгоритма заключается в введении матрицы скрытых переменных <math>G</math>, где <math>g_{ij} \equiv P(\theta_j |x_i)</math> обозначает вероятность принадлежности <math>i</math>-го объекта <math>j</math>-му кластеру.

На Е-шаге вычисляется ожидаемое значение скрытых переменных, на М-шаге выполняется максимизация логарифма полного правдоподобия, результатом которой являются новые значения параметров модели.

На выходе получаем набор параметров модели для каждого кластера <math>\Theta = (w_1,...,w_k;\;\mu_1,...,\mu_k;\;\Sigma_1,...,\Sigma_k)</math>, где <math>w_j</math> — вес <math>j</math>-го кластера в смеси нормальных распределений, <math>\mu_j</math> — математическое ожидание <math>j</math>-ой компоненты смеси, <math>\Sigma_j</math> — матрица ковариации <math>j</math>-ой компоненты смеси.

E-шаг:

На E-шаге вычисляется значение скрытых переменных <math>g_{ij}</math> по текущему приближению параметров <math>\Theta</math>.

<math>g_{ij} = \frac{w_jp_j(x_i)}{\sum_{s=1}^k w_sp_s(x_i)}</math>, что интерпретируется как вероятность принадлежности объекту <math>x_i</math> к <math>j</math>-ому кластеру.

M-шаг:

Будем максимизировать логарифм полного правдоподобия:

<math>Q(\Theta) = \ln\prod_{i=1}^mp(x_i) = \sum_{i=1}^m\ln\sum_{j=1}^kw_jp_j(x_i) \rightarrow \max_{\Theta}</math>, при условии <math>\sum_{j=1}^kw_j=1</math>

Решением оптимизационной задачи являются формулы для пересчета параметров:

<math>w_j = \frac1m\sum_{i=1}^m g_{ij}</math>,

<math>\mu_j = \frac1{mw_j}\sum_{i=1}^m g_{ij}x_i</math>,

<math>\Sigma_j = \frac1{mw_j}\sum_{i=1}^m g_{ij}(x_i - \mu_j)(x_i - \mu_j)^T,\; j = 1, \dots, k</math>

== Вычислительное ядро алгоритма ==
Вычислительное ядро алгоритма представляет собой итерационное вычисление всех параметров модели, независимое по <math>m</math> объектам выборки <math>X</math>.
На каждой итерации алгоритма на Е-шаге пересчитывается значение скрытых переменных, на M-шаге пересчет параметров модели с учетом скрытых переменных.

== Макроструктура алгоритма ==
Как записано в [[#Вычислительное ядро алгоритма|описании ядра алгоритма]], основную часть метода составляют вычисления элементов матрицы G на E шаге, и пересчет параметров <math>\Theta</math> на M-шаге.

== Схема реализации последовательного алгоритма ==
# Инициализация параметров
# for iter = 1 : max_iterations
# [E-шаг]
## вычисление <math>\Sigma_j^{-1}</math> и <math>\frac1{(2\pi)^{d/2}\sqrt{|\Sigma_j|}}, j = 1 : k</math>
## вычисление <math>g_{ij},\;i = 1 : m, \; j = 1 : k</math>
## вычисление <math>LL_i</math> (логарифм правдоподобия), <math>\;i = 1 : m</math>
# [M-шаг]
## вычисление <math>\tilde w_j = \sum_{i=1}^m g_{ij}, \; j = 1 : m</math>
## вычисление <math>\tilde \mu_j = \sum_{i=1}^m g_{ij}x_i,\; j = 1 : k</math>
## вычисление <math>\tilde \Sigma_j = \sum_{i=1}^m g_{ij}(x_i - \mu_j)^T(x_i - \mu_j),\; j = 1 : k</math>
## нормировка <math>w_j = \frac{\tilde w_j}{m}</math>, <math>\mu_j = \frac{\tilde \mu_j}{w_j}, \tilde \Sigma_j = \frac{\tilde \Sigma_j}{w_j}, \;j = 1 : k</math>
# вычисление изменения логарифма правдоподобия<math>\Delta LL = fabs(\sum_{i=1}^m LL^{iter}_i - \sum_{i=1}^m LL^{iter - 1}_i)</math>
# if (<math>\Delta LL < \varepsilon</math>) then break;
# end for

== Последовательная сложность алгоритма ==
E-шаг:
# вычисление обратной матрицы <math>\Sigma_j^{-1}, j = 1 : k</math> при фиксированном <math>j</math> для двумерного случая по явным формулам имеет сложность <math>O(d^2)</math>, для всех кластеров — <math>O(d^2k)</math>
# вычисление <math>g_{ij}, i = 1 : m, j = 1 : k</math> при фиксированных <math>i, j</math> имеет сложность <math>O(d)</math>, сложность вычисления матрицы G — <math>O(dmk)</math>
# вычисление <math>LL_i, i = 1 : m</math> при фиксированном <math>i</math> имеет сложность <math>O(k)</math>, для всех объектов имеет сложность <math>O(mk)</math>,
M-шаг:
# вычисление <math>w_j, j = 1 : k</math> при фиксированном <math>j</math> имеет сложность <math>O(m)</math>, для весов всех кластеров — <math>O(mk)</math>
# вычисление <math>\mu_j, j = 1 : k</math> при фиксированном <math>j</math> имеет сложность <math>O(dm)</math>, для всех кластеров — <math>O(dmk)</math>
# вычисление <math>\Sigma_j, j = 1 : k</math> при фиксированном <math>j</math> имеет сложность <math>O(d^2m)</math>, для всех кластеров — <math>O(d^2mk)</math>
# нормировка <math>w</math>, <math>\mu_j = \frac{\mu_j}{w_j}, \Sigma_j = \frac{\Sigma_j}{w_j}, j = 1 : k</math> имеет сложность <math>O(k)</math>, <math>O(dk)</math>, <math>O(d^2k)</math>
# вычисление изменения логарифма правдоподобия<math>\Delta LL</math> имеет сложность <math>O(1)</math>

Сложность алгоритма на одной итерации:

<math>O(k(d^2+dm+m+m+dm+d^2m+1+d+d^2)) = O(d^2mk)</math>, так как мы рассматриваем задачу для двумерного случая, то есть <math>d=2</math>, множитель <math>d^2</math> можно отнести в константу, итоговая сложность вычисления на одной итерации <math>O(mk)</math>.

Для <math>n</math> итераций итоговая сложность алгоритма будет равна:

<math>O(mkn)</math>, где <math>m</math> — число объектов, <math>k</math> — число кластеров, <math>n</math> — число итераций.

== Информационный граф ==

Опишем граф алгоритма для следующих входных данных: <math>m = 3,\; k = 2,\; d = 2</math>, то есть 3 входных объекта и 2 кластера.

На рис.1 показана макроструктура EM-алгоритма. Входными данными в таком случае являются матрица <math>X \in \R^{3 \times 2}</math> и число кластеров <math>k = 2</math>.
На шаге <math>\mathbf{init}</math> происходит инициализация начальных приближений параметров модели и затем итеративное повторение <math>\mathbf{E}</math> и <math>\mathbf{M}</math> шагов алгоритма.

[[file:EM.png|thumb|center|300px|Рис.1. Граф EM-алгоритма с отображением входных и выходных данных]]

E-шаг. На рис.2 детально изображена схема E-шага.
Входные параметры <math>x_1,\; x_2,\; x_3 \in \R^{1 \times 2}</math> являются строчками входной матрицы <math>X</math>, также на вход подаются текущие приближения векторов средних значений (<math>\mu_1, \;\mu_2</math>), матриц ковариаций (<math>\Sigma_1, \Sigma_2</math>) и весов <math>w</math>.

Вершинами <math>\mathbf{eI}</math> обозначена операция нахождения обратной матрицы <math>\Sigma_j^{-1},\; j = 1,2</math>. Вершины группы <math>\mathbf{eS}</math> обозначают вычитание векторов <math>x_i - \mu_j,\; i = 1,2,3; \; j = 1, 2</math>. Салатовые узлы графа <math>\mathbf{eE}</math> обозначают вычисление ненормированного значения <math>g_{ij}, \;i = 1,2,3;\;j=1,2</math> по формулам из раздела [[#Схема реализации последовательного алгоритма|описания алгоритма]]. Далее выход вершин этой группы подаётся на вход вершинам <math>\mathbf{eN}</math>, которые обозначают нормировку, затем в <math>\mathbf{eL}</math> происходит подсчет логарифма правдоподобия. На выходе этого графа получаются скрытые переменные <math>g_{ij}</math> и логарифм правдоподобия LL.

[[file:EM_E_step.png|thumb|center|500px|Рис.2. Граф E-шага с отображением входных и выходных данных]]

M-шаг. На рисунке 3 изображена схема M-шага.
Входными параметрами являются: исходные объекты <math>x_1,\; x_2,\; x_3 \in \R^{1 \times 2}</math>, скрытые переменные <math>g_{11},\;g_{21},\;g_{31},\;\mu_1</math> для пересчета параметров первого кластера и <math>g_{12},\;g_{22},\;g_{32},\;\mu_2</math> — для второго.

Вершина <math>\mathbf{m}\boldsymbol{\mu}</math> обозначает подсчет слагаемого математического ожидания для одного объекта, затем на шаге <math>\mathbf{mS_1}</math> происходит суммирование слагаемых, и, наконец, на шаге <math>\mathbf{mN_1}</math> нормировка математического ожидания, выходом являются <math>\mu_1,\;\mu_2</math>.
Вершина <math>\mathbf{m}\boldsymbol{\Sigma}</math> обозначает подсчет слагаемого матрицы ковариации для одного объекта, затем на шаге <math>\mathbf{mS_2}</math> происходит суммирование слагаемых, и, наконец, на шаге <math>\mathbf{mN_2}</math> нормировка матрицы ковариации, выходом являются <math>\Sigma_1,\;\Sigma_2</math>.
Операция <math>\mathbf{mS_3}</math> обозначает вычисление ненормированного веса для одного шага, затем при выполнении <math>\mathbf{mN_3}</math> происходит нормировка весов, выходом являются <math>w_1,\;w_2</math>.

[[file:EM_M_step.png|thumb|center|500px|Рис.3. Граф M-шага с отображением входных и выходных данных]]

На рис.1 показана структура ЕM-алгоритма для кластеризации, на рис.2 — структура E-шага и на рис.3 — структура M-шага.

== Ресурс параллелизма алгоритма ==
Как видно из информационного графа, возможно распараллеливание как по кластерам, так и по объектам. Однако, в реальных задачах число кластеров много меньше числа объектов, поэтому распараллеливание по кластерам нецелесообразно.

В данной статье рассматривается вариант распараллеливания по объектам. Стоит отметить, что важно корректно организовать работу с параметрами модели (матрицами ковариаций, средними значениями и весами), чтобы не произошло ситуации гонки за ресурсами <ref>Воеводин В.В., Воеводин Вл.В. Параллельные вычисления. - СПб.: БХВ-Петербург, 2002. - 608 с.</ref>.

== Входные и выходные данные алгоритма ==

'''Входные данные''': плотная вещественная матрица объектов-признаков <math>X \in \R^{m \times d}</math> и количество кластеров <math>k</math>, где <math>m</math> — количество объектов, <math>d</math> — количество кластеров.

'''Объём входных данных''': <math>m \times d + 1</math>.

'''Выходные данные''': вектор весов <math>w \in \R^{k \times 1}</math>, <math>\;\;k</math> векторов математических ожиданий <math>\mu_j \in \R^{d \times 1}</math>, <math>\;\;k</math> матриц ковариации <math>\Sigma \in \R^{d \times d}</math>

'''Объём выходных данных''': <math>k \times (d \times d + d + 1)</math>

== Свойства алгоритма ==

EM-алгоритм не является устойчивым, результат его работы сильно зависит от начальных приближений параметров. При неудачном выборе начальных приближений алгоритм может не сойтись или сойтись в локальный экстремум.

Также, алгоритм не является детерминированным. Так как в начале работы алгоритма происходит инициализация начальных параметров случайным образом (с учетом положительной определенности и симметричности матрицы ковариации), он не может быть детерминирован.

Алгоритм сбалансирован по E и M шагам, затраты на выполнение этих этапов примерно одинаковы.

= ЧАСТЬ. Программная реализация алгоритма =

== Особенности реализации последовательного алгоритма ==
В данном разделе приведем код реализации последовательного алгоритма.

<source lang="c++">
double_vector em_algo::expectation_step(double_matrix& features)
{
long n_objects = features.size1();
int n_clusters = parameters.sigmas.size();
double pi = boost::math::constants::pi<double>();

// precalculate inverse matrices and dets
std::vector<double_matrix> sigmas_inverted(n_clusters);
std::vector<double> norm_distribution_denominator(n_clusters);
for (int i = 0; i < n_clusters; ++i)
{
double_matrix sigma_inverted(parameters.sigmas[i].size1(), parameters.sigmas[i].size2());
double det = InvertMatrix(parameters.sigmas[i], sigma_inverted);
if (det == 0)
{
std::cerr << "Matrix can not be inverted\n";
exit(1);
}
norm_distribution_denominator[i] = sqrt(pow(2 * pi, parameters.n_features) * det);
sigmas_inverted[i] = sigma_inverted;
}

hidden_vars = double_matrix(n_objects, n_clusters);
double_vector log_likelihood(n_objects, 0);

for (auto i = 0; i < n_objects; ++i)
{
double_matrix_row x(features, i);
double norm_value = 0;
for (auto j = 0; j < n_clusters; ++j)
{
double_matrix_column current_means(parameters.means, j);
double_vector x_centered = x - current_means;

double exp_power = -0.5 * inner_prod(prod(x_centered, sigmas_inverted[j]), x_centered);
hidden_vars(i, j) = parameters.weights(j) * exp(exp_power) / norm_distribution_denominator[j];

norm_value += hidden_vars(i, j);
}
double_matrix_row hidden_vars_row(hidden_vars, i);
if (norm_value != 0)
{
hidden_vars_row = hidden_vars_row / norm_value;
log_likelihood(i) = log(inner_prod(hidden_vars_row, parameters.weights));
}

}
return log_likelihood;
}

void em_algo::maximization_step(double_matrix& features)
{
int n_objects = features.size1();

double_vector w = double_vector(n_clusters, 0.0);
double_matrix means = double_matrix(parameters.n_features, n_clusters, 0.0);
std::vector<double_matrix> sigmas;
for (int j = 0; j < n_clusters; ++j)
sigmas.push_back(double_matrix(parameters.n_features, parameters.n_features, 0.0));

for (int i = 0; i < n_objects; ++i)
{
double_matrix_row x_i = row(features, i);

for (int j = 0; j < n_clusters; ++j)
{
double g = hidden_vars(i, j);
w(j) += g;

double_matrix_column single_mean = column(means, j);

single_mean += g * x_i;

double_vector x_centered = x_i - column(parameters.means, j);
for (int k = 0; k < parameters.n_features; ++k)
for (int l = 0; l < parameters.n_features; ++l)
sigmas[j](k, l) = sigmas[j](k, l) + g * x_centered(k) * x_centered(l);
}
}
// update weights
parameters.weights = w / n_objects;

for (int j = 0; j < n_clusters; ++j) {
double weight = w(j);
// update means
double_matrix_column means_old = column(parameters.means, j);
double_matrix_column means_new = column(means, j);
means_old = means_new / weight;

// update sigmas
parameters.sigmas[j] = sigmas[j] / weight;
for (int k = 0; k < parameters.n_features; ++k)
parameters.sigmas[j](k, k) = parameters.sigmas[j](k, k) + tol;
}
}

bool em_algo::is_likelihood_stabilized(double_vector likelihood, double_vector previous_likelihood)
{
double likelihood_diff = sum(likelihood) - sum(previous_likelihood);
return fabs(likelihood_diff) < tol;
}

model em_algo::process(double_matrix& features, int max_iterations)
{
int iteration = 0;
double_vector likelihood, previous_likelihood;
while (iteration++ < max_iterations && (iteration <= 2 || !is_likelihood_stabilized(likelihood, previous_likelihood)))
{
previous_likelihood = likelihood;
likelihood = expectation_step(features);
maximization_step(features);
}
return parameters;
}
</source>

Возможной реализацией является перестановка местами циклов по объектам и по кластерам на E и М шаге. В данном случае внешний цикл проходит по объектам, так как подразумевается дальнейшая реализации распараллеливания по объектам. При реализации только последовательного алгоритма более понятной версией будет реализация внешнего цикла по кластерам, и внутреннего по объектам, но такая реализация увеличит число обращений в память и общее время работы алгоритма.

== Локальность данных и вычислений ==

== Возможные способы и особенности параллельной реализации алгоритма ==

== Масштабируемость алгоритма и его реализации ==
===Масштабируемость реализации алгоритма===
Для проведения экспериментов по масштабируемости были выбраны следующие параметры алгоритма: были зафиксированы число кластеров <math>k = 4 </math>, и, также, было зафиксировано ядро рандомизации, чтобы избавиться от случайности различного выбора начального приближения параметров. Для показательности результатов условие досрочного завершения работы алгоритма в случае стабилизации логарифма правдоподобия игнорировалось, и для каждого запуска проводилось 50 итераций EM-алгоритма.

Для экспериментов было сгенерировано 20 выборок разного размера: от 40000 объектов до 200000 с шагом в 10000. Для каждой выборки время работы алгоритма усреднялось по нескольким запускам, чтобы избежать выбросов.

Для работы с многопоточностью использовалась библиотека OpenMP. С помощью нее были распараллелены основные циклы по объектам на E и M шаге.

Эксперименты проводились на компьютере с процессором Intel(R) Core(TM) i7-5820K @ 3.30GHz, который поддерживает до 12ти потоков.

Как видно на рис. 4, производительность растет до 12 процессов, после чего время работы алгоритма снова начинает увеличиваться, то есть использование более 12 процессов при рассматриваемой конфигурации процессора не имеет смысла. Заметим также, что в увеличением числа точек, скорость работы программы линейно увеличивается.

[[file:EM performance.png|thumb|center|700px|Рис. 4 Время работы EM алгоритма в зависимости от числа процессов и размера задачи]]

В результате проведённых экспериментов был получен следующий диапазон эффективности реализации алгоритма:

* минимальная эффективность реализации 0,00072%;
* максимальная эффективность реализации 25.5037%.

[[file:EM_Efficiency.png|thumb|center|700px|Рис. 4 Эффективность EM алгоритма в зависимости от числа процессов и размера задачи]]

== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Существуют следующие последовательные реализации EM-алгоритма для кластеризации: [http://docs.opencv.org/2.4/modules/ml/doc/expectation_maximization.html# opencv], [http://scikit-learn.org/stable/modules/mixture.html scikit-learn].

Также существует несколько параллельных реализаций, описанных в следующих статьях:

В статье <ref>López-de-Teruel P. E., García J. M., Acacio; The Parallel EM Algorithm and its Applications in Computer Vision</ref> авторы предлагают распределить вычисление скрытых переменных для каждого объекта между процессорами и на каждой итерации производить нормализацию. M-шаг предлагается параллелить по компонентам, что требует реализации корректного взаимодействия между процессорами. Предложенный вариант распараллеливания был реализован и протестирован авторами статьи с помощью MPI библиотеки MPICH.

Авторы статьи <ref>Abhinandan Das, Mayur Datar, Ashutosh Garg; Google News Personalization: Scalable Online Collaborative Filtering
[[en:Description of algorithm properties and structure]]</ref> используют MapReduce для распараллеливания EM-алгоритма для PLSI моделей.

= Литература =

<references \>

Обсуждение участника:Мария Готман

2016-11-16T11:24:04Z

Algoman:

== Замечания второго рецензента ==
1) Проверьте орфографию - нашел слова "вычисляеются", "вычЕсленные"

2) П1.2 Разъясните по поводу входной матрицы m на d. Что такое m, что такое d? При кластеризации более привычно говорить о наборе входных объектов

3) Там же. Нужно больше пояснений по Е и М шагам. Сейчас одни формулы. Что такое N(*,*,*) и p()?

4) П 1.5 Надо добавить - как вычисляется дельта LL.

5) П 1.7 Информационный граф нужно строить для общего случая, а не при конкретных значениях параметров.

6) П 1.9 Что подразумевается под меткой кластера?

7) П 1.10 Определение вычислительной мощности алгоритма здесь неуместно. Этот пункт посвящен свойствам алгоритма

== Замечания к [[Алгоритм_кластеризации,_основанный_на_максимизации_ожидания]] ==

1) список литературы лучше оформить средствами разметки - см. как сделано в [[Разложение_Холецкого_(метод_квадратного_корня)]]

Список литературы исправлен.

== Замечения от 31.10 ==

"- В конце статьи должен быть приведен список всех источников, откуда бралась информация по алгоритму. Если вы используется готовый рисунок, то сслыку на источник нужно разместить либо в подписи к рисунку, либо в тексте, где стоит ссылка на рисунок."

какой источник картинок с графиками (п1.1 и 2.4)? созданы ли они авторами для этой статьи, публиковались ли где-то ещё?

Все рисунки создавались авторами статьи, исходники есть, больше нигде не публиковались.

== Замечания к пункту 2.4 от 16.11.2016 ==

* зачем выделен подпункт 2.4.1 с дублирующим заголовком?
* оба рисунка - номер 4
* подписи к первому рисунку 4 практически не читаются
* "Как видно на рис. 4, производительность растет до 12 процессов, после чего время работы алгоритма снова начинает увеличиваться..." на рисунке не видно, что происходит после 12 процессов - следует переформулировать предложение

Участник:Noite/EM-алгоритм кластеризации

2016-11-16T11:16:26Z

Algoman:

Обсуждение участника:Noite

2016-11-16T11:16:10Z

Algoman:

== Замечания к [[Участник:Noite/EM-алгоритм_кластеризации]] ==

1) лишняя строка "Алгоритм кластеризации, основанный на максимизации ожидания (EM-алгоритм)" перед содержанием --- убрано

2) отсутствует оценка высоты и ширины ЯПФ параллельного алгоритма во врезке в начале статьи --- врезка исправлена

'''Ниже - замечания второго рецензента'''

3) Во врезке так и не появилась информация по поводу параллельного алгоритма --- исправлено

4) Из содержания нужно убрать ссылку [5] --- имеется ввиду из заголовка раздела? или подобную ссылку вообще нельзя использовать? пока ссылка перенесена из заголовка внутрь раздела

5) В формулировке задачи в п1.1 нет разъяснения параметра m --- формулировка задачи кластеризации изменена

6) В п1.2 парметры m, n, k почему-то превратились в M, N, K --- параметры m,n,k изменены в п1.1 и во врезке на M,N,K соответственно

7) П 1.5. Как инициализируются скрытые переменные gamma? Выравнивание псевдокода местами нарушено. Слово "большУю" - здесь лучше использовать значок ударения --- слово большУю исправлено. Скрытые переменные могут быть инициализированы любым образом, поскольку первый E-шаг алгоритма их в любом случае перезапишет. Выравнивание псевдокода изменено.

8) П 1.7 Информационный граф: на рисунке омега превратилась в w, гамма - в Y. --- в используемом редакторе изображений для гаммы использовался следующий символ: γ - символ гамма, взятый из википедии. То, что он похож на Y - визуальное совпадение.

9)П 1.9 Выходные данные - сказано о векторе n. Поясните, какое значение он имеет в терминах алгоритма кластеризации. --- пояснение добавлено

== Замечания к пункту 2.4 от 16.11.2016 ==

* текущую информацию в п 2.4 можно оставить, но для выполнения задания практикума исследование масштабируемости должно быть проведено самостоятельно

Участник:ЕкатеринаКозырева/Алгоритм динамической иерархической кластеризации CHAMELEON

2016-11-16T11:10:41Z

Algoman:

{{algorithm
| name = Алгоритм динамической иерархической кластеризации CHAMELEON
| serial_complexity = <math>O(nm + n log n + m^2 log m)</math>
| input_data = <math>\frac{n (n - 1)}{2}</math>
| output_data = <math>n</math>
| pf_height = <math>O(n+ n log(n) + m^2 log (m) + m log(m))</math>
| pf_width = <math>O(n)</math>
}}

Автор описания [[Участник:ЕкатеринаКозырева|Е.А.Козырева]]
= Свойства и структура алгоритмов =

== Общее описание алгоритма ==
Алгоритм CHAMELEON был предложен в 1999 году тремя учеными из университета Миннесоты – George Karypis, Eui-Hong (Sam) Han и Vipin Kumar<ref>George Karypis, Eui-Hong (Sam) Han и Vipin Kumar, «Chameleon: Hierarchical Clustering Using Dynamic Modeling», 1999.</ref>.

Предназначен для решения задач кластеризации. Кластеризация (или кластерный анализ) — это задача разбиения множества объектов на группы, называемые кластерами. Внутри каждой группы должны оказаться «похожие» объекты, а объекты разных группы должны быть как можно более отличны.

CHAMELEON - это агломеративный иерархический алгоритм кластеризации, ключевой особенностью которого является то, что он учитывает и взаимную связность, и сходство при определении наиболее похожей пары подкластеров, основываясь на динамической модели. Это означает, что в процессе кластеризации два кластера объединяются, только если их относительная взаимная связность и относительное взаимное сходство являются высокими по отношению к внутренней взаимосвязанности кластеров и близости элементов внутри кластеров. Кроме того, CHAMELEON использует подход для моделирования степени взаимосвязанности и близости между каждой парой кластеров, который учитывает внутренние характеристики самих кластеров. Таким образом, он может автоматически адаптироваться к внутренним характеристикам объединяемых кластеров.

CHAMELEON находит кластеры в наборе данных с помощью трехфазного алгоритма. На первой фазе происходит построение графа, путём добавления рёбер по принципу k ближайших соседей. На второй фазе CHAMELEON группирует полученные элементы в множество относительно небольших подграфов. Во время третьей фазы применяется агломеративный иерархический алгоритм кластеризации, с помощью которого находятся естесственные кластеры путем многократного объединения подграфов, полученных на прошлом этапе.

[[File:Chameleon.png|1000px|thumb|center|Рисунок 1. Общая структура алгоритма CHAMELEON]]

== Математическое описание алгоритма ==

''Исходные данные'':

* Множество из n точек <math>V= {v_{ij}}</math> в метрическом пространстве, которое задано симметрической матрицей расстояний <math>A</math> размера <math>n\times n</math>.
* <math>k</math> - количество ближайших соседей для вершин, <math>k \in N, k \leq n</math>.
* <math>l</math> - наименьшее число вершин, которое может содержать наибольший подграф на 2-м этапе, <math>l \in N, l \leq n</math>.

''Обозначения'':

* <math>G = (V, E)</math> - граф, полученный путём соединения каждой точки с её <math>k</math> ближайшими соседями.

* <math>K= \{K_{i}\}</math> - разбиение множества <math>V</math> на набор попарно непересекающихся связных подмножеств, полученное в результате выполнения второй фазы алгоритма.

* <math>G_{2} = (K, E_{2})</math> - взвешенный граф, вершинами которого являются получившиеся подграфы, а ребрами - количество ребер исходного графа, соединяющих соответствующие подграфы.

* <math>C = \{C_{i}\}</math> - итоговое разбиение множества вершин графа <math>G_{2}</math> на набор кластеров.

''Вспомогательные понятия''

*<math>EC_{(C_{i},C_{j})}</math> - абсолютная взаимная связность пары кластеров <math>C_{i}, C{j}</math>. Определяется как сумма весов ребер, соединяющих вершины, принадлежащие <math>C{i}</math> c вершинами из <math>C{j}</math>. Внутренняя связность <math>EC_{(C_{i},C_{i})}</math> вычисляется как сумма ребер, входящих в разделитель, разбивающий <math>C{i}</math> на два равных подграфа.

*<math>RI_{(C_{i},C_{j})} = \frac{|EC_{(C_{i},C_{j})}|}{(|EC_{C_{i}}|+|EC_{C_{j}}|)/2}</math> - относительная взаимная связность пары кластеров <math>C_{i}, C{j}</math>

*<math>S_{EC_{(C_{i},C_{j})}}</math> - абсолютное взаимное сходство пары кластеров <math>C_{i}, C{j}</math>. Подсчитывается как среднее сходство между соединенными вершинами, принадлежащими <math>C{i}</math> и <math>C{j}</math> соответственно. Соединения обусловлены разбиением общего графа, полученного на первом этапе алгоритма.

*<math> RC_{(C_{i},C_{j})}= \frac{S_{EC_{(C_{i},C_{j})}}}{\frac{|C_{i}|}{|C_{i}+C_{j}|}*S_{EC_{(C_{i})}}+\frac{|C_{i}|}{|C_{i}+C_{j}|}*S_{EC_{(C_{j})}}}</math> - относительное взаимное сходство пары кластеров <math>C_{i}, C{j}</math>. Определяется как абсолютное сходство между этой парой кластеров, нормализованное с учетом их внутреннего сходства<ref>http://studopedia.ru/7_41934_algoritm-dinamicheskoy-ierarhicheskoy-klasterizatsii-CHAMELEON.html</ref>.

'''Первый этап'''

На первом этапе, согласно графо-ориентированному подходу, происходит построение графа <math>G = (V, E)</math> на матрице сходства объектов по принципу k ближайших соседей. Две вершины такого графа соединяет ребро, если объект, соответствующий любой из этих вершин попадает в число k наиболее близких объектов для объекта, соответствующего другой вершине из данной пары.
[[Файл:Снимок chameleon 2.png|2000px|thumb|Рисунок 2. Объекты в пространстве - слева, граф по принципу 1-го ближайшего соседа - по центру, граф по принципу 3-х ближайших соседей - справа ]]

'''Второй этап'''

Алгоритм разделяет полученный граф на множество сравнительно малых подграфов <math>K= \{K_{i}\}</math>. Разделение происходит последовательно. На каждом шаге выбирается подграф, содержащий наибольшее число вершин. Этот граф разделяется на два подграфа так, что разделитель ребер графа минимален и каждый из получаемых подграфов содержит не менее 25 % вершин исходного графа. Процесс разделения останавливается, когда наибольший подграф содержит меньше некоторого заданного числа вершин. Обычно величина этого параметра задается равной значению от 1 до 5 % от числа объектов. Полученное множество связных графов считается множеством начальных кластеров, на котором требуется провести последовательное иерархическое объединение.

'''Третий этап'''

Третий этап заключается в итеративном преобразовании множества подграфов <math>K= \{K_{i}\}</math> в множество кластеров <math>C = \{C_{i}\}</math>. Алгоритм осуществляет агломеративную иерархическую кластеризацию на основании показателей <math>EC_{(C_{i},C_{j})}</math>, <math>S_{EC_{(C_{i},C_{j})}}</math>, <math>RI_{(C_{i},C_{j})} </math>, <math> RC_{(C_{i},C_{j})}</math>. Существует две стратегии анализа показателей сходства. Первая подразумевает наличие некоторых пороговых значений <math>T_{RI}</math> и <math>T_{RC}</math>. В соответствии с этой стратегией, алгоритм для каждого кластера <math>C_{i}</math> проверяет, отвечают ли смежные (наиболее близкие) ему кластеры условиям:

*<math>RI_{(C_{i},C_{j})} \geqslant T_{RI}</math>

*<math>RC_{(C_{i},C_{j})} \geqslant T_{RC}</math>

Если более одного смежного кластера отвечает этим условиям, то алгоритм выбирает для объединения наиболее связный кластер (граф), то есть такой кластер <math>C_{j}</math>, с которым у кластера <math>C_{i}</math> получается наибольшая абсолютная взаимная связность. По завершению прохода по всем кластерам, созданные таким образом пары объединяются. Параметры <math>T_{RI}</math> и <math>T_{RC}</math> могут использоваться для изменения характеристик получаемых кластеров.

Вторая стратегия заключается в использовании специальной функции, объединяющей понятия относительной взаимной связности и относительного взаимного сходства. На каждом шаге выбираются те кластеры для объединения, которые максимизируют эту функцию:

<math>RI_{(C_{i},C_{j})}*RC_{(C_{i},C_{j})}^\alpha</math>,

где <math>\alpha</math> выбирается пользователем. Если <math>\alpha > 1 </math>, то алгоритм придает большее значение относительному взаимному сходству, а если <math>\alpha < 1 </math>, то большее значение имеет относительная взаимная связность.

''Вычисляемые данные'':

<math>U = (u_1, u_2, ..., u_n)</math> - n-мерный вектор, где <math>u_i \in N_{[C]}</math> - порядковый номер кластера, к которому принадлежит вершина i исходного множества V.

== Вычислительное ядро алгоритма ==

Алгоритм имеет три вычислительных ядра, по одному на каждый этап.

На первом этапе вычислительным ядром является процесс нахождения <math>k</math> ближайших соседей для каждой вершины, который заключается в анализе матрицы расстояний.

На втором этапе вычислительным ядром является процесс поиска подходящего разбиения очередного подграфа на два графа с минимизацией разделителя ребер графа.

На третьем этапе вычислительным ядром является расчет величин <math>EC_{(C_{i},C_{j})}</math>, <math>S_{EC_{(C_{i},C_{j})}}</math>, <math>RI_{(C_{i},C_{j})} </math>, <math> RC_{(C_{i},C_{j})}</math> для каждой пары смежных кластеров.

== Макроструктура алгоритма ==

Как уже рассказывалось ранее, алгоритм включает в себя три основных этапа, каждый из которых, по сути, является отдельным алгоритмом. Этапы выполняются последовательно относительно друг друга.

Макрооперация на первом этапе - процедура нахождения <math>k</math> ближайших соседей, на втором - процедура разбиения наибольшего подграфа на два графа, на третьем - процедура вычисления показателей сходства, на основе которых принимается решение о слиянии подграфов в кластер.

== Схема реализации последовательного алгоритма ==

'''Первый этап'''
<source lang="cpp">
int n; //количество вершин
int k; //количество соседей
int A[n][n] //матрица расстояний
int D[k] //массив вершин-соседей
int E[n][n] //матрица ребер графа <math>G_{2} = (K, E_{2})</math>
for i=1 to n-1 do
{
for j=i+1 to n do
{
//заполняем массив вершин-соседей вставляя новые вершины, если они ближе, чем самая далекая из массива.
}
for j=0 to k do
{
//для каждой вершины соседа заполняем соответствующую ячейку из матрицы E[n][n] единицей
}

}
</source>

'''Второй этап'''

1. Все связные подграфы в отсортированном порядке помещаются в список;
2. Берем наибольший элемент списка, вычисляем количество его вершин. Если число вершин > l, то идем в пункт 3. Иначе в пункт 5;
3. Разбиваем подграф на два подграфа таким образом, чтобы разделитель ребер графа был минимален и каждый из получаемых подграфов содержал не менее 25 % вершин исходного графа;
4. Добавляем полученные элементы в список подграфов таким образом, чтобы список оставался отсортированным. Идем в пункт 2;
5. Нашли искомое множество подграфов math>K = \{K_{i}\}</math>;
6. Создаем и заполняем матрицу матрицу расстояний для графа <math>G_{2} = (K, E_{2})</math>. Получаем искомый набор рёбер <math>E_{2}</math>.

'''Третий этап'''

1. Заводим два массива: а) массив кластеров C, полученных на предыдущем этапе, б) массив объединений кластеров F, которые мы будем получать на этом этапе;
2. Берем следующий кластер <math>C_{i}</math> (на первом шаге - первый). Если все кластеры просмотрены, идем в пункт 6;
3. Берем следующий кластер <math>C_{j}, i<>j</math>. Если все кластеры просмотрены, то идем в пункт 2;
4. Проверяем смежность <math>C_{i}</math> и <math>C_{j}</math>. Если не смежны, то возвращаемся в пункт 3. Если смежны, идем в пункт 5;
5. Рассчитываем показатели <math>RI_{(C_{i},C_{j})}</math> и <math> RC_{(C_{i},C_{j})}</math>. Проверяем, удовлетворяют ли найденные значения условиям:
*<math>RI_{(C_{i},C_{j})} \geqslant T_{RI}</math>
*<math>RC_{(C_{i},C_{j})} \geqslant T_{RC}</math>
Если нет, то идем в пункт 3. Иначе если смежность пары кластеров выше, чем у предыдущих найденных, то <math>F_{i}=j</math>. Идем в пункт 3;
6. Если в списке F есть хотя бы одна пара кластеров для слияния, то выполняем слияние, обновляем массив кластеров и массив объединений кластеров. Идем в пункт 2.

== Последовательная сложность алгоритма ==

1) Для построения графа на основе метода k ближайших соседей для n вершин требуется <math>O(n log(n))</math> операций <ref>J.H. Friedman, J.L. Bentley, and R.A. Finkel. An algorithm for ﬁnding best matches in logarithmic expected time. ACM Transactions on Mathematical Software, 3:209–226, 1977.</ref>; для наборов данных большой размерности эта величина составляет <math>O(n^2)</math> операций <ref>S. Berchtold, C. Bohm, D. Keim, and H.-P. Kriegel. Cost model for nearest neighbor search in high dimensional data space. In Proc. of Symposium on Principles of Database Systems, Tucson, Arizona, 1997.</ref>;

2) Для выделения множества сравнительно малых связных подграфов требуется <math>nm</math> операций, где <math>m</math> - количество подграфов, полученных на втором этапе алгоритма;

3) Формирование набора кластеров, на основе множества подграфов, полученных на предыдущем этапе, требует <math>m^2log(m)</math> операций.

Итого, для n вершин получаем последовательную сложность <math>O(n log(n)+nm+m^2log(m))</math>.

== Информационный граф ==
[[File:СК.png]]

== Ресурс параллелизма алгоритма ==

Первый этап работы алгоритма можно распределить между <math>n</math> процессами. На вход каждому процессу подается своя вершина, далее происходит процедура поиска <math>k</math> ближайших соседей. Параллельная сложность составляет <math>O(n)</math>.

Второй и третий этапы можно распараллелить частично.

Второй этап распараллеливается путем подачи на вход свободному процессу очередного подграфа для разделения. Число итераций оценивается в <math>O(n log(n))</math>.

Третий этап делится на расчет показателей схожести и соединение подграфов в кластеры. Процесс расчета показателей можно распараллелить, подавая каждому процессу на вход пару подграфов. Сложность этого процесса оценивается как <math>m log(m)</math>. Соединение подграфов в кластеры выполняется последовательно, сложность процесса составляет <math>m^2 log(m)</math>

Таким образом получаем общую параллельную сложность алгоритма: <math>O(n+ n log(n) + m^2 log (m) + m log(m))</math>

== Входные и выходные данные алгоритма ==
'''Входные данные'''

1. Симметрическая матрица <math>A</math> расстояний между элементами данных размера <math>n\times n</math> с нулями на главной диагонали (<math>a_{ii}= 0, i = 1, \ldots, N</math>).

2. <math>k</math> - количество ближайших соседей для вершин (рекомендуемое значение <math>k</math> от 5 до 20 в зависимости от количества анализируемых объектов).

3. <math>l</math> - наименьшее число вершин, которое может содержать наибольший подкластер на 2-м этапе . Величина этого параметра варьируется от 1 до 5 % от общего числа объектов.

'''Объём входных данных'''

<math>\frac{n (n - 1)}{2}</math> (в силу симметричности и нулевой главной диагонали достаточно хранить только над/поддиагональные элементы).

'''Выходные данные'''

Вектор из <math>n</math> чисел <math>u_{1}, u_{2}, \ldots, u_{N}</math>, где <math>u_{i}</math> - целое число, соответствующее кластеру <math>i</math>-го объекта.

'''Объём выходных данных'''

<math>n</math>

== Свойства алгоритма ==
Соотношение последовательной и параллельной сложности на первом этапе является ''линейным'' для больших наборов данных и логарифмическим для n вершин. На втором этапе сложно оценить это соотношение - оно сильно зависит от параметров <math>k</math> и <math>l</math>. На третьем этапе соотношение равно <math>O(1)</math>;

Оценка ''вычислительной мощности'' выглядит следующим образом:

<math>O(1)</math> для 1-го этапа;

<math>O(\frac{nm}{n^2+m^2})</math> для 2-го этапа;

<math>O(\frac{m^2log(m)}{m^2+n})</math> для 3-го этапа;

Алгоритм является ''недетерминированным''. Хотя 1-й этап детерминирован, на 2-ом этапе могут быть найдены различные разбиения на подграфы, что повлияет и на итоговый результат работы алгоритма.

= Программная реализация алгоритма =
== Особенности реализации последовательного алгоритма ==
== Локальность данных и вычислений ==
== Возможные способы и особенности параллельной реализации алгоритма ==
== Масштабируемость алгоритма и его реализации ==

см. позднее

== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Последовательная реализация алгоритма доступна по ссылке <ref>http://read.pudn.com/downloads36/sourcecode/math/115779/chameleon/chameleon.c__.htm</ref>.

CHAMELEON можно реализовать с использованием графовых библиотек METIS <ref>http://glaros.dtc.umn.edu/gkhome/metis/metis/overview
</ref>, hMETIS <ref>http://glaros.dtc.umn.edu/gkhome/metis/hmetis/overview</ref> и RANN <ref>https://cran.r-project.org/web/packages/RANN/index.html</ref>.

Существует исследование, связанное с реализацией CHAMELEON посредством технологии OpenMP, с которым можно ознакомиться здесь <ref>http://research.ijcaonline.org/volume79/number8/pxc3891600.pdf</ref>.

Параллельных реализаций алгоритма CHAMELEON не найдено.

= Литература =

Участник:Артем Таран/Графо-ориентированный алгоритм кластеризации CHAMELEON

2016-11-16T11:10:26Z

Algoman:

{{algorithm
| name = Графо-ориентированный алгоритм кластеризации CHAMELEON
| serial_complexity = <math>O(n^2+nm+m^2log(m))</math>
| pf_height = <math>O(n + log(n) + mlog(m) + m^2log(m))</math>
| pf_width = <math>O(n)</math>
| input_data = <math>\frac{n (n - 1)}{2}</math>
| output_data = <math>n</math>
}}

Статью подготовили: [[Участник:Артем_Таран|Артём Таран Иванович]] (разделы 1.1 - 1.10, 2.7), [[Участник:ShimchikN|Шимчик Никита Владимирович]] (разделы 1.1 - 1.10, 2.7).
== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===

Кластеризация — многомерная статистическая процедура, выполняющая сбор данных, содержащих информацию о выборке объектов, и затем упорядочивающая объекты в сравнительно однородные группы (кластеры) с минимизацией межкластерного сходства и максимизацией внутрикластерного сходства.

Графо-ориентированный алгоритм кластеризации CHAMELEON<ref name="rt">http://www-users.cs.umn.edu/~han/dmclass/chameleon.pdf</ref> - алгоритм, который измеряет сходство двух кластеров на основе
динамической модели. В процессе кластеризации два кластера объединяются, только если показатели взаимосвязанности и близости между двумя кластерами являются высокими по отношению к показателям внутренней взаимосвязанности кластеров и близости элементов внутри этих кластеров. Процесс слияния с использованием динамической модели, использующийся в данном алгоритме облегчает открытие
природных и однородных кластеров. Методология динамического моделирования кластеров, использующаяся в CHAMELEON,
применима ко всем типам данных, для которых может быть построена матрица подобия.

Алгоритм кластеризации CHAMELEON включает в себя три этапа:

1) Построение графа, путём добавления рёбер по принципу k ближайших соседей.

2) Выделение множества сравнительно малых связных подграфов.

3) Формирование набора кластеров, на основе множества подграфов, полученных на предыдущем этапе.

[[Файл:Графы k ближайших соседей.jpg|1000px|thumb|center|Графы k ближайших соседей: 1) объекты в пространстве, 2) граф по принципу 1-го ближайшего соседа, 3) граф по принципу 2-го ближайшего соседа, 4) граф по принципу 3-х ближайших соседей<ref name="rt">http://www-users.cs.umn.edu/~han/dmclass/chameleon.pdf</ref>]]

=== Математическое описание алгоритма ===
==== Данные ====
* '''Исходные данные''': множество из <math>n</math> точек <math>V = \{v_{i}\}</math> в метрическом пространстве, которое может быть задано в виде треугольной матрицы расстояний <math>A</math> размера <math>n\times n</math>.

* '''Промежуточный результат после первого этапа''': граф <math>G = (V, E)</math>, полученный путём соединения каждой точки с её <math>k</math> ближайшими соседями.

* '''Промежуточный результат после второго этапа''': разбиение множества <math>V</math> на набор <math>K = \{K_{i}\}</math> попарно непересекающихся связных подмножеств, из которого образуется взвешенный граф <math>G_{2} = (K, E_{2})</math>.

* '''Промежуточный результат после третьего этапа''': итоговое разбиение множества вершин графа <math>G_{2}</math> на набор кластеров <math>C = \{C_{i}\}</math>.

* '''Вычисляемые данные''': n-мерный вектор <math>v</math> (элементы <math>v_{i}</math>), показывающий отображение исходного множества точек на набор кластеров <math>C</math>.

==== Определения ====

* ''Абсолютная взаимная связность между парой кластеров <math>C_{i}</math> и <math>C_{j}</math>'' определяется как сумма весов ребер, соединяющих вершины, принадлежащие <math>C_{i}</math> с вершинами из <math>C_{j}</math>. Эти ребра, фактически, входят в разделитель ребер графа, состоящего из кластеров <math>C_{i}</math> и <math>C_{j}</math>, и разбивающим его на подграфы <math>C_{i}</math> и <math>C_{j}</math>. Обозначается эта величина как
<math>EC_{(C_{i},C_{j})}</math>. Внутреннюю связность <math>EC_{C_{i}}</math> кластера <math>C_{i}</math> можно вычислить как сумму ребер, входящих в разделитель ребер, разбивающий <math>C_{i}</math> на два совершенно равных подграфа.

* ''Относительная взаимная <math>RI_{(C_{i},C_{j})}</math> связность пары кластеров <math>C_{i}</math> и <math>C_{j}</math>'' определяется формулой:

<math>RI_{(C_{i},C_{j})} = \frac{2*|EC_{(C_{i},C_{j})}|}{|EC_{C_{i}}|+|EC_{C_{j}}|}</math>

Учитывая значения относительной взаимной связности, можно добиться получения кластеров разного размера, формы и плотности, то есть общего внутреннего сходства.

* ''Абсолютное взаимное сходство между парой кластеров <math>C_{i}</math> и <math>C_{j}</math>'' подсчитывается как среднее сходство между соединенными вершинами, принадлежащими <math>C_{i}</math> и <math>C_{j}</math> соответственно. Эти соединения обусловлены предыдущим разбиением общего графа, полученного на матрице сходства.

* ''Относительное взаимное сходство <math>RC_{(C_{i},C_{j})}</math> между парой кластеров <math>C_{i}</math> и <math>C_{j}</math>'' определяется как абсолютное сходство между этой парой кластеров, нормализованное с учетом их внутреннего сходства и вычисляется по формуле:

<math> RC_{(C_{i},C_{j})}= \frac{S_{EC_{(C_{i},C_{j})}}}{\frac{|C_{i}|}{|C_{i}+C_{j}|}*S_{EC_{(C_{i})}}+\frac{|C_{i}|}{|C_{i}+C_{j}|}*S_{EC_{(C_{j})}}}</math>,

где <math>S_{EC_{(C_{i})}}</math> и <math>S_{EC_{(C_{i})}}</math> - средние веса ребер (значения сходства), принадлежащих разделителю ребер кластеров <math>C_{i}</math> и <math>C_{j}</math> соответственно,
и <math>S_{EC_{(C_{i},C_{j})}}</math> - средний вес ребер, соединяющих вершины <math>C_{i}</math> с вершинами <math>C_{j}</math>, причем ребра принадлежат разделителю ребер <math>EC_{(C_{i})}</math>, определенному ранее.

Далее, алгоритм применяет агломеративную иерархическую кластеризацию с использованием вышеозначенных показателей. Причем существует две стратегии их учета. Первая подразумевает наличие некоторых пороговых значений <math>T_{RI}</math> и <math>T_{RC}</math>. В соответствии с этой стратегией, алгоритм для каждого кластера <math>C_{i}</math> проверяет, отвечают ли смежные (наиболее близкие) ему кластеры условиям:

*<math>RI_{(C_{i},C_{j})} \geqslant T_{RI}</math>

*<math>RC_{(C_{i},C_{j})} \geqslant T_{RC}</math>

Если более одного смежного кластера отвечает этим условиям, то алгоритм выбирает для объединения наиболее связный кластер (граф), то есть такой кластер <math>C_{j}</math>, с которым у кластера <math>C_{i}</math> получается наибольшая абсолютная взаимная связность. По завершению прохода по всем кластерам, созданные таким образом пары объединяются. Параметры <math>T_{RI}</math> и <math>T_{RC}</math> могут использоваться для изменения характеристик получаемых кластеров.

Вторая стратегия заключается в использовании специальной функции, объединяющей понятия относительной взаимной связности и относительного взаимного сходства. На каждом шаге выбираются те кластеры для объединения, которые максимизируют эту функцию:

<math>RI_{(C_{i},C_{j})}*RC_{(C_{i},C_{j})}^\alpha</math>,

где <math>\alpha</math> выбирается пользователем. Если <math>\alpha > 1 </math>, то алгоритм придает большее значение относительному взаимному сходству, а если <math>\alpha < 1 </math>, то большее значение имеет относительная взаимная связность. Разумеется, данный подход позволяет получить полную дендрограмму кластерного анализа<ref name="rty">http://studopedia.ru/7_41934_algoritm-dinamicheskoy-ierarhicheskoy-klasterizatsii-CHAMELEON.html</ref>.

=== Вычислительное ядро алгоритма ===

На первом этапе работы алгоритма вычислительным ядром можно считать процесс нахождения k ближайших соседей для каждой отдельной вершины.

На втором этапе работы алгоритма вычислительным ядром является поиск разбиения графа на два подграфа с минимизацией разделителя рёбер графа.

На третьем этапе работы алгоритма вычислительным ядром является расчёт <math>EC_{(C_{i},C_{j})}</math>, <math>RC_{(C_{i},C_{j})}</math> и <math>RI_{(C_{i},C_{j})}</math> для пары смежных кластеров, а также их слияние.

=== Макроструктура алгоритма ===

Алгоритм CHAMELEON выполняется в 3 этапа, последовательных относительно друг друга. Каждый этап соответствует отдельному алгоритму.

* Макрооперацией на первом этапе является процедура выделения k ближайших соседей.

* Макрооперацией на втором этапе является процедура разбиения наибольшего подграфа на каждой итерации.

* Макрооперациями на третьем этапе являются процедуры вычисления метрики для принятия решения об объединении кластеров и объединение кластеров на каждой итерации.

=== Схема реализации последовательного алгоритма ===

* Первый этап (псевдокод):
integer n; // Количество точек.
integer k; // Параметр k
integer A[n][n]; // Верхняя треугольная матрица расстояний между точками.

integer E[n][n]; // Верхняя треугольная матрица рёбер графа G - изначально инициализирована нулями.
foreach (integer i in (1,n-1) ) {
integer Neighbors[k]; // матрица, используемая хранения ближайших соседей
integer countN = 0;

foreach (integer j in (i+1, n) ) {
// Заполняем матрицу Neighbors, добавляя новые элементы и увеличивая счётчик countN.
// Когда countN станет равен k, новые элементы будут вставляться на место старых, либо отбрасываться.
}

foreach (integer j in (0, countN) ) {
E[min(i,j), max(i,j)] = 1;
}
}
return E;

* Второй этап:
[[File:Диаграмма_шаг_2.png]]

* Третий этап:
[[File:Chameleon_stage_3.png|611px]]

=== Последовательная сложность алгоритма ===
1) Построение графа на основе метода k ближайших соседей в худшем случае требует <math>O(n^2)</math> операций;

2) Для выделения множества сравнительно малых связных подграфов требуется <math>nm</math> операций;

3) Формирование набора кластеров, на основе множества подграфов, полученных на предыдущем этапе, требует <math>m^2log(m)</math> операций.

Итого, получаем последовательную сложность <math>O(n^2+nm+m^2log(m))</math>.

=== Информационный граф ===

[[File:Chameleon_inforgraph.png|811px]]

=== Ресурс параллелизма алгоритма ===

Первый этап работы алгоритма можно распределить между <math>n</math> процессами: в этом случае каждому процессу назначается своя точка и происходит поиск <math>k</math> ближайших соседей. Таким образом, его параллельная сложность составляет <math>O(n)</math>.

На втором этапе количество задействованных процессов может варьироваться в зависимости от входных данных. В худшем случае число итераций можно оценить как <math>O(log(n))</math>.

На третьем этапе можно распараллелить процесс расчёта метрик сходства между кластерами, однако итоговое слияние всё равно должно выполняться последовательно.
Поскольку процесс сравнения кластеров возможно распараллелить, сложность 3-го этапа составляет <math>mlog(m) + m^2log(m)</math>.

Таким образом, суммарная параллельная сложность оказывается равна <math>O(n + log(n) + mlog(m) + m^2log(m))</math>.

=== Входные и выходные данные алгоритма ===

* Входные данные:

1) Треугольная матрица <math>A</math> размера <math>n\times n</math> (где n — количество объектов), в которой элементу <math>a_{ij}</math> соответствует расстояние между i-м и j-м объектами.

2) Количество ближайших соседей <math>k</math> для вершин (рекомендуемое значение <math>k</math> от 5 до 20 в зависимости от количества анализируемых объектов).

3) Наименьшее число вершин, которое может содержать наибольший подграф на 2-м этапе <math>l</math>. Величина этого параметра варьируется от 1 до 5 % от общего числа объектов.

* Объём входных данных: <math>\frac{n (n - 1)}{2}</math>

* Выходные данные: n-мерный вектор <math>v</math>, в котором элементу <math>v_{i}</math> соответствует номер кластера, присвоенный i-му объекту

* Объём выходных данных: <math>n</math>

=== Свойства алгоритма ===

Первый этап алгоритма обладает хорошим ресурсом параллелизма: параллельная сложность его выполнения составляет <math>O(n)</math>, что намного лучше последовательной оценки <math>O(n^2)</math>.

У второго и третьего этапов алгоритма сложно полностью оценить ресурсы параллелизма. Но оба этапа возможно частично распараллелить.

'''Вычислительную мощность''' для разных этапов алгоритма можно оценить как:

1 этап: <math>O(1)</math>

2 этап: <math>O(\frac{nm}{n^2+m^2})</math>

3 этап: <math>O(\frac{m^2log(m)}{m^2+n})</math>

Детерминированность: Важной особенностью данного алгоритма является его недетерминированность. Несмотря на то, что 1-й этап детерминирован, алгоритм в целом является недетерминированным, так как на 2-ом этапе могут быть найдены различные разбиения на подграфы, а это повлияет и на итоговый результат работы алгоритма.

== Программная реализация алгоритма ==

=== Особенности реализации последовательного алгоритма ===

=== Локальность данных и вычислений ===

=== Возможные способы и особенности параллельной реализации алгоритма ===

=== Масштабируемость алгоритма и его реализации ===

=== Динамические характеристики и эффективность реализации алгоритма ===

=== Выводы для классов архитектур ===

=== Существующие реализации алгоритма ===

Существует несколько последовательных реализаций алгоритма. С одной из них можно ознакомиться по ссылке <ref name="tra">http://www.codeforge.com/article/192925</ref>.

Возможна реализация алгоритма CHAMELEON с использованием графовых библиотек, как, например METIS <ref name="tru">http://glaros.dtc.umn.edu/gkhome/metis/metis/overview</ref> , hMETIS <ref name="tri">http://glaros.dtc.umn.edu/gkhome/metis/hmetis/overview</ref> и RANN <ref name="tro">https://cran.r-project.org/web/packages/RANN/index.html</ref>.

Параллельных реализаций алгоритма CHAMELEON найдено не было. Однако существует исследование, связанное с реализацией CHAMELEON посредством технологии OpenMP, с которым можно ознакомиться здесь <ref name="tr">http://research.ijcaonline.org/volume79/number8/pxc3891600.pdf</ref>.

== Литература ==

<references \>

Участник:Steve/Графо-ориентированный алгоритм кластеризации CHAMELEON

2016-11-16T11:10:04Z

Algoman:

Авторы: Кириллов Валентин Владимирович: 1.1, 1.3, 1.4, 1.7, 1.9, 1.10, 2.7;
Холопкин Степан Андреевич: 1.2, 1.5, 1.6, 1.7, 1.8, 1.10

{{algorithm
| name = Графо-ориентированный алгоритм кластеризации CHAMELEON
| serial_complexity = <math>O(n^2+nm+n log n + m^2 log(m))</math>
| pf_height = <math>O(log(n))</math>
| pf_width = <math>O(n)</math>
| input_data = <math>n</math>
| output_data = <math>n</math>
}}

= ЧАСТЬ. Свойства и структура алгоритмов =

== Общее описание алгоритма ==
Алгоритм CHAMELEON первые представлен в 1999 департаментом компьютерных наук и инженерии, университет Миннесоты, США. Авторы George Karypis, Eui-Hong (Sam) Han, Vipin Kumar<ref>CHAMELEON: A Hierarchical Clustering Algorithm Using Dynamic Modeling George Karypis Eui-Hong (Sam) Han Vipin Kumar Department of Computer Science and Engineering University of Minnesota 4-192 EECS Bldg., 200 Union St. SE Minneapolis, MN 55455, USA Technical Report #99–007 {karypis,han,kumar}@cs.umn.edu </ref> <ref> ЭКСПЕРИМЕНТАЛЬНЫЕ РЕЗУЛЬТАТЫ ИССЛЕДОВАНИЯ КАЧЕСТВА КЛАСТЕРИЗАЦИИ РАЗНООБРАЗНЫХ НАБОРОВ ДАННЫХ С ПОМОЩЬЮ МОДИФИЦИРОВАННОГО АЛГОРИТМА ХАМЕЛЕОН © Т. Б. Шатовская, А. А. Заремская </ref>.

Кластеризация – процесс разбиения множества данных по некоторому признаку на такие группы, что в пределах одной группы данные максимально схожи по данному признаку, а в разных группах данные максимально различны. Иерархические алгоритмы кластеризации строят не одно разбиение множества данных на кластеры, а систему вложенных разбиений. CHAMELEON является агломеративным методом (снизу вверх), когда после первого разбиения на мелкие кластеры пары близлежащих кластеров итеративно объединяются в общий кластер. На первом этапе CHAMELEON использует алгоритм разделения графа для получения набора относительно малых кластеров. На втором этапе, для объединения кластеров, полученных на первом этапе, в настоящие кластеры, используется иерархическая агломеративная кластеризация. Таким образом, алгоритм, фактически, является гибридным, построенным комбинацией графо-ориентированных и классических иерархических методов.

На первом этапе, согласно графо-ориентированному подходу, происходит построение графа на матрице сходства объектов по принципу k ближайших соседей. Две вершины такого графа соединяет ребро, если объект, соответствующий любой из этих вершин попадает в число k наиболее близких объектов для объекта, соответствующего другой вершине из данной пары.
[[Файл:Cham1.jpg ]][[Файл:Cham2.jpg ]][[Файл:Cham3.jpg ]]

На рисунке изображены: объекты в пространстве – слева, граф по принципу 1-го ближайшего соседа – в середине, граф по принципу 3-х ближайших соседей – справа <ref> International Journal of Computer Applications (0975 – 8887) Volume 79 – No8, October 2013 11 Parallel Algorithm for the Chameleon Clustering Algorithm using Dynamic Modeling </ref>.

Далее, алгоритм разделяет полученный граф на множество сравнительно малых подграфов. Разделение происходит последовательно. На каждом шаге выбирается подграф, содержащий наибольшее число вершин. Этот граф разделяется на два подграфа, так, что разделитель ребер графа минимален и каждый из получаемых подграфов содержит не менее некоторого процента вершин исходного графа. Процесс разделения останавливается, когда наибольший подграф содержит меньше некоторого заданного числа вершин. Полученное множество связных графов считается множеством начальных кластеров, на котором требуется провести последовательное иерархическое объединение.

На втором этапе, алгоритм последовательно объединяет кластеры, используя значение их относительной взаимной связности и относительного взаимного сходства. Только если оба эти значения достаточно высоки у двух кластеров, они объединяются.

Относительная взаимная связность пары кластеров определяется абсолютной взаимной связностью кластеров, нормализованной с учетом внутренней связности каждого кластера (подграфа). Нормализация используется для того, чтобы исключить тенденцию к преимущественному объединению крупных кластеров, у которых, определенно, значение взаимной связности будет больше, вследствие их размера.

[[Файл:Scheme_algo.jpg | thumb | center | 1000px | CHAMELEON: A Hierarchical Clustering Algorithm Using Dynamic Modeling]]

На рисунке представлена схема работы алгоритма CHAMELEON.

== Математическое описание алгоритма ==

Исходные данные: набор данных (точек) произвольной размерности.

Выходные данные: набор кластеров, то есть групп исходных данных.

Шаги алгоритма:

1) Представление набора данных в виде <math>G = (V, E)</math> с помощью алгоритма <math>k</math>-ближайших соседей: <math>e = (v_i, v_j) \in E</math>, если <math>dist(v_i, v_j) \in sorted(\{r | r = dist(v_i, v_k), k = 1,...,n\})[1..k]</math>, причем <math>weight(e) = dist(v_i, v_j)</math>

2) Разбиение графа на небольшие кластеры. Для этого необходимо создать множество <math>C = G</math> и выполнять цикл со следующими шагами на каждой его итерации:

* Найдем <math>C_{greatest}</math> такой, что <math>|C_{greatest}| = \max_{1 \leq j \leq |C|}|C_j|</math>

* Если <math>\frac{|C_{greatest}|}{|V|} > MINSIZE</math>, то разделить <math>C_{greatest}</math> на 2 кластера <math>C_1</math> и <math>C_2</math>, удалить <math>C_{greatest}</math> из <math>C</math>, и добавить <math>C_1</math> и <math>C_2</math> в <math>C</math>.

* В противном случае завершил цикл.

3) Создать начальный набор кластеров <math>C_{current} = C</math>. Затем выполнять цикл со следующими шагами на каждой итерации:

* Для каждой пары кластеров <math>C_i, C_j \in C_{current}</math> вычислить следующие показатели:
** <math>EC(C_i, C_j) = \sum_{e \in conn(C_i, C_j)}weight(e)</math>, где <math>conn(C_i, C_j) = \{(v, w) | v \in C_i, w \in C_j\}</math>
** <math>EC(C_i) = \sum_{e \in mincut(C_i)}weight(e)</math>, где <math>mincut(C_i)</math> - минимальный разрез <math>C_i</math>. Аналогичным образом вычислить <math>EC(C_j)</math>.
** <math>\bar{S}_{EC(C_i, C_j)} = \frac{EC(C_i, C_j)}{|conn(C_i, C_j)|} </math>
** <math>\bar{s}_{EC(C_i)} = \frac{EC(C_i)}{|mincut(C_i)|}</math>
* Вычислить относительную взаимную связность и относительное взаимное сходство двух текущих кластеров:
** <math>RI(C_i, C_j) = \frac{|EC(C_i,C_j)|}{\frac{|EC(C_i)| + |EC(C_j)|}{2}}</math>
** <math>RC(C_i, C_j) = \frac{\bar{S}_{EC(C_i,C_j)}}{\frac{|C_i|}{|C_i|+|C_j|}\bar{S}_{EC(C_i)} + \frac{|C_j|}{|C_i|+|C_j|}\bar{S}_{EC(C_j)}}</math>
* Если <math>RI(C_i, C_j)^\alpha RC(C_i, C_j) > t</math>, то слить данную пару кластеров, иначе - перейти к следующей паре. Здесь <math>\alpha</math> - параметр, с помощью которого можно выбирать, какой из показателей важнее - относительная взаимная связность или относительное взаимное сходство, а <math>t</math> - параметр, показывающий самый нижний уровень сходства кластеров, при котором их можно слить.
* Если на какой-то итерации цикла ни одна пара кластеров не была слита, то завершить цикл.

== Вычислительное ядро алгоритма ==
Из математического описания алгоритма следует, что вычислительное ядро алгоритма сосредоточено в вычислении относительной взаимной связности и относительного взаимного сходства каждой пары кластеров на каждой итерации алгоритма.

<math>RI(C_i, C_j) = \frac{|EC(C_i,C_j)|}{\frac{|EC(C_i)| + |EC(C_j)|}{2}}</math>

<math>RC(C_i, C_j) = \frac{\bar{S}_{EC(C_i,C_j)}}{\frac{|C_i|}{|C_i|+|C_j|}\bar{S}_{EC(C_i)} + \frac{|C_j|}{|C_i|+|C_j|}\bar{S}_{EC(C_j)}}</math>

== Макроструктура алгоритма ==
В первой части первого этапа алгоритма применяется алгоритм построения графа методом k ближайших соседей.

Во второй части первого этапа алгоритма при разбиении кластера на два подкластера применяется алгоритм пакета METIS от Karypis Lab.

В виде макроопераций представлены вычисления относительной взаимной связности и относительного взимного сходства кластеров.

== Схема реализации последовательного алгоритма ==
Реализация последовательного алгоритма на псевдокоде выглядит следующим образом:

<source lang="c">
// параметры
// число ближайших соседей в первой фазе алгоритма
int k;
// минимальный относительный размер каждого из начальных кластеров
double MINSIZE;
// параметры, определяющий, что важнее в определении похожести
// двух кластеров - относительная взаимосвязанность
// или относительная близость
int alpha;
// порог, определяющий минимальную похожесть кластеров, необходимую
// для их слияния
int threshold;
int n = number_of_vertices;
double graph_matrix[n][n] = {0};
// фаза 1 - для каждой вершины найдем k ближайших к ней и соединим
// получившиеся наборы ребрами
for (int i = 0; i < n; i++) {
double k_nearest_indices[k] = findKNearest(i);
for (int near_ind = 0; near_ind < k; near_ind++) {
connect(i, near_ind);
}
}
// фаза 2 - осуществление начального разбиения на кластеры
Cluster initial_clusters[] = all(graph_matrix);
while (1) {
Cluster greatest = getGreatestCluster(initial_clusters);
if (greatest.size() / n < MINSIZE) {
break;
} then {
Cluster c1;
Cluster c2;
(c1, c2) = greatest.splitClusterIntoTwo();
initial_clusters.remove(greatest);
initial_clusters.push_back(c1);
initial_clusters.push_back(c2);
}
}
// фаза 3 - выполним слияние кластеров
Cluster current_clusters[] = initial_clusters;
bool already_merged[] = {false};
Cluster clusters_merged[];
// возвращает логическую переменную, показывающую,
// произошло ли слияние или нет
bool merge(int i, int j) {
if (already_merged(i) || already_merged(j)) {
return false;
}

Cluster c1 = current_clusters[i];
Cluster c2 = current_clusters[j];

double RI = calcRI(c1, c2);
double RC = calcRC(c1, c2);
double similarity = pow(RI, alpha) * RC;
if (similarity > threshold) {
already_merged(i) == true;
already_merged(j) == true;

Cluster merged = connect_clusters(i, j);
clusters_merged.push_back(merged);

return true;
}
return false;
}
// слияние
while (1) {
bool some_merging_happened = false;
for (each pair (i, j) in current_clusters) {
some_merging_happened ||= merge(i, j);
}
if (some_merging_happened) {
current_clusters = clusters_merged;
clusters_merged = null;

already_merged = {false};
} else {
break;
}
}
// результат
print current_clusters
</source>

== Последовательная сложность алгоритма ==

Для расчета последовательной сложности алгоритма необходимо рассчитать сложность каждого из его этапов. Везде далее будем считать, что <math>n</math> – размер входной выборки данных (иначе говоря, число точек). Также через <math>m</math> обозначим число начальных кластеров, появившихся после этапа 2 алгоритма, и для простоты анализа будем считать, что размер каждого из кластеров равен <math>\frac{n}{m}</math>.
* Построение графа <math>k</math>-ближайших соседей. Для нахождения <math>k</math> ближайших соседей одной фиксированной вершины в общем случае требуется <math>O(n)</math> шагов, следовательно, для всего этапа требуется <math>O(n^2)</math> шагов.
* Построение начального набора кластеров. Пусть дан граф <math>G=(V,E)</math>. Один шаг алгоритма – разбиение кластера максимального размера на 2 подкластера – может быть выполнен за <math>O(|V|+|E|)</math> шагов. Так как мы исходной точкой для данного этапа является граф <math>k</math>-ближайших соседей, <math>|E|=O(|V|)</math>, следовательно, шаг может быть выполнен за <math>O(|V|)=O(n)</math> шагов. Суммарная же сложность всего этапа будет равна <math>O(n log(\frac{n}{m}))=O(n log(n))</math>, так как в итоге получаются <math>m</math> кластеров.
* Сложность третьего этапа зависит от сложности вычисления относительной взаимной связанности и относительного взаимного сходства. Эти две операции вычисляются с помощью нахождения минимального разреза соответствующего кластера, что означает, что их сложность пропорциональна числу элементов в каждом кластере. В частности, время, необходимое на разделение каждого из изначальных m кластеров, равно <math>O(\frac{n}{m})</math>, а суммарно необходимо <math>O(n)</math> времени. Далее, необходимо сделать <math>m - 1</math> объединений <math>m</math> изначальных кластеров, отсюда, суммарная сложность вычислений похожести равна <math>O(nm)</math>. Суммарное время, требуемое для нахождение наиболее похожей пары кластеров, равно <math>O(m^2 log(m))</math>.
* Таким образом, итоговая сложность алгоритма равна <math>O(n^2+nm+n log n + m^2 log(m))</math>.

== Информационный граф ==
Покажем информационный граф основной части алгоритма. Он представляет собой трехмерный набор точек-итераций главного цикла. Плоскость <math>(i,j)</math> являет собой последовательную проверку на слияние пары кластеров с номерами <math>i</math> и <math>j</math>. Ось <math>h</math> являет собой номер текущего набора кластеров, иначе говоря – номер итерации главного цикла. Операции слияния обозначены кружком с буквой “m” внутри.

[[Файл:Scheme4.jpg]]

Из графа алгоритма видно, что переходить к следующей итерации главного цикла можно лишь тогда, когда будет завершена предыдущая (дуги-зависимости идут от операций слияния строго вверх).

== Ресурс параллелизма алгоритма ==
Как видно из графа алгоритма, операции слияния, находящиеся на одной итерации-плоскости главного цикла, не зависят друг от друга, и, следовательно, могут быть выполнены параллельно. Исходя из этого, предлагается следующая схема выполнения параллельного выполнения: каждая операция слияния на одной итерации главного цикла вызывается асинхронно, а в конце одной итерации главного цикла происходит ожидание окончания работы всех операций и подготовка к следующей итерации.

Стоит заметить, что создание числа параллельных потоков, равного текущему количеству кластеров, вряд ли можно считать реальной задачей. Поэтому будем считать, что каждый параллельный поток вычисляет ровно один столбец матрицы-плоскости информационного графа, что означает, что параллельная сложность выполнения одной итерации алгоритма равна <math>O(n)</math>. Высота полученного графа (то есть, число позиций по вертикальной оси) будет равна <math>O(log(n))</math>, так как на каждом шаге цикла число кластеров уменьшается в среднем в 2 раза.

== Входные и выходные данные алгоритма ==
Входные данные: массив <math>n</math> точек произвольной размерности.

Выходные данные: <math>n</math> чисел <math>q_1, q_2, ..., q_n</math>, где <math>q_i</math> - целое число, соответствующее кластеру <math>i</math>-й точки.

== Свойства алгоритма ==
Алгоритм делится на три части, которые выполняются последовательно и отдельно друг от друга. В пределах каждой части возможна параллельная реализация.

Детерминированность: Важной особенностью данного алгоритма является его недетерминированность. Несмотря на то, что первая часть первого этапа детерминирована, остальные две части выполняются итеративно и останавливаются по достижении заданной точности.

Приближенно оценить вычислительную мощность алгоритма можно как отношение числа операций к объему входных данных:

<math>\frac{n^2+nm+nlog(n)+m^2log(m)}{n+m} = n + \frac{nlog(n)}{n+m} + \frac{m^2log(m)}{n+m} < n + log(n) + mlog(m)</math>

что являет собой сумму линейной, логарифмической и произведения линейной и логарифмической функций.

= ЧАСТЬ. Программная реализация алгоритма =

== Особенности реализации последовательного алгоритма ==

== Локальность данных и вычислений ==

== Возможные способы и особенности параллельной реализации алгоритма ==

== Масштабируемость алгоритма и его реализации ==

== Динамические характеристики и эффективность реализации алгоритма ==

== Выводы для классов архитектур ==

== Существующие реализации алгоритма ==
Существующая реализация алгоритма CHAMELEON есть в составе пакета CLUTO от авторов алгоритма <ref> [http://glaros.dtc.umn.edu/gkhome/views/cluto Data Clustering Software CLUTO - Software for Clustering High-Dimensional Datasets]. </ref>.

= Литература =

<references \>

Участник:Ruslanlazovskiy/CHAMELEON

2016-11-16T11:09:37Z

Algoman:

{{algorithm
| name = CHAMELEON
| serial_complexity = <math>O(n*m + n*log{n} + m*log{m})</math>
| pf_height = <math>O(n)</math> - этап 1. <math>O(q)</math> - отдельная итерация этапа 3.
| pf_width = <math>O(n)</math> - этап 1. <math>O(q)</math> - отдельная итерация этапа 3.
| input_data = <math>n^2 / 2</math>
| output_data = <math>n</math>
}}

Авторы статьи:
[https://algowiki-project.org/ru/%D0%A3%D1%87%D0%B0%D1%81%D1%82%D0%BD%D0%B8%D0%BA:Ruslanlazovskiy|Лазовский Р. А.] ( разделы 1.1 - 1.4 , 1.7 , 1.8 ),
[https://algowiki-project.org/ru/%D0%A3%D1%87%D0%B0%D1%81%D1%82%D0%BD%D0%B8%D0%BA:%D0%9C%D1%83%D1%81%D1%82%D0%B0%D1%84%D0%B0%D0%B5%D0%B2_%D0%AD%D0%BB%D1%8C%D0%B2%D0%B8%D0%BD_%D0%AD%D0%BB%D1%8C%D0%BC%D0%B0%D0%BD%D0%BE%D0%B2%D0%B8%D1%87|Мустафаев Э. Э.] ( разделы 1.5 , 1.6 , 1.9 , 1.10 , 2.2 )

==Свойства и структура алгоритма==
===Общее описание алгоритма===
CHAMELEON – алгоритм динамической иерархической кластеризации графа, то есть процесса разбиения графа на несколько подграфов-кластеров таким образом, что данные внутри одного кластера имеют максимально схожи, а данные в разных кластерах — максимально различны. В классических алгоритмах кластеризации схожесть объектов определяется с помощью некоторой метрики ( простейший пример - евклидова метрика ). Не следует путать задачу кластеризации с задачей классификации - в последней характеристики объекта, необходимые для попадания в тот или иной класс, известны заранее, в рассматриваемой же задаче они становятся известны в процессе решения. Первоначально алгоритм был описан в статье<ref>CHAMELEON: A Hierarchical Clustering Algorithm Using Dynamic Modeling. George Karypis, Eui-Hong Han, Vipin Kumar. IEEE Computer 32(8): 68-75, 1999</ref>.

Алгоритм CHAMELEON работает в 3 этапа. На первом этапе исходное множество объектов организуется в граф по принципу k ближайших соседей. На втором этапе этого граф разбивается на достаточно малые подграфы-кластеры. На третьем этапе происходит агломеративная иерархическая кластеризация полученных подграфов в соответствии с одной из выбранных метрик ( возможные метрики будут подробно описаны далее ). Число получаемых в итоге кластеров в явном виде не задаётся.

===Математическое описание алгоритма===

Исходные данные: Первоначально исходными данными алгоритма являются <math>n</math> векторов длины <math>p</math>, каждый из которых соответствует одному объекту. На основании значений элементов этих векторов строится матрица смежности размера <math>n * n</math> ( возможно сокращение требуемого объема памяти до <math>(n*(n - 1))/ 2</math> в соответствии с выбранной метрикой. К исходным данным также относится набор параметров. Это <math>k</math> - количество ближайших соседей на первом этапе алгоритма, <math>q</math> - отношение количества вершин в наибольшем подграфе по отношению к общему числу объектов на втором этапе алгоритма, а также параметры <math>T_{RI}, T_{RI}</math> - пороговые значения, после которых прекращается агломеративная кластеризация на третьем этапе. Следует особо отметить, что число получаемых в итоге кластеров заранее не известно, хотя на него и можно повлиять изменением значений перечисленных параметров.

Первый этап алгоритма: На первом этапе на основании матрицы смежности строится граф <math>G = (V, E)</math> <math>k</math> ближайших соседей, где <math>V</math> - множество вершин графа ( т.е. объекты ), а <math>E</math> - множество ребер графа ( т.е. построенные связи между ближайшими соседями ). Указанный граф не обязательно является связным.

Второй этап алгоритма: Граф <math>G = (V, E)</math> итеративно разбивается на множество подграфов <math>G_{i} = (V_{i}, E_{i}), i = 1 .. m</math>, где <math> \cup V_{i} = V, i = 1 .. m</math>. Параметр <math>m</math> явно не задаётся, выполнение этого этапа алгоритма прекращается по выполнении описанных далее условий. На каждой итерации выбирается <math>G_{b}</math> с числом вершин, наибольшим среди всех подграфов, имеющихся на данной итерации. Этот граф разбивается на 2 подграфа <math>G_{bi}</math> и <math>G_{bj}</math> таких, что 1) <math>min(V_{bi},V_{bj}) >= 0.25 * V_{b}</math> ( имеется ввиду количество вершин ) и 2) <math>\sum{E_{kl}}, E_{kl} = (v_{k}, v_{l}), v_{k} \in V_{bi} , v_{l} \in V_{bj} </math> минимальна среди всех разбиений, удовлетворяющих 1). Итеративный процесс прекращается, когда <math>\sum{v_{b}} <= q * \sum{v} , v_{b} \in V_{b} , e \in E</math> ( имеется ввиду количество вершин ). Здесь <math>q</math> - задаваемый параметр, на практике он варьируется от <math>0.01</math> до <math>0.05</math>. Полученные подграфы называются малыми кластерами.

Третий этап алгоритма: Множество кластеров <math>G_{i} = (V_{i}, E_{i}), i = 1 .. m</math> итеративно преобразуется в множество кластеров <math>G_{j} = (V_{j}, E_{j}), j = 1 .. l</math>, <math>l <= m</math>. Для этого вводятся следующие понятия:

<math>EC_{(C_{i},C_{j})}</math> - абсолютная взаимная связность пары кластеров <math>C_{i}, C{j}</math>. Это суть сумма весов ребер, соединяющих вершины, принадлежащие <math>C{i}</math> c вершинами из <math>C{j}</math>. <math>EC_{(C_{i},C_{i})}</math> вычисляется как сумма ребер, входящих в разделитель, разбивающий <math>C{i}</math> на два равных подграфа. 
<math>S_{EC_{(C_{i},C_{j})}}</math> - абсолютное взаимное сходство пары кластеров <math>C_{i}, C{j}</math>. Это суть среднее сходство между соединенными вершинами, принадлежащими <math>C{i}</math> и <math>C{j}</math> соответственно. Соединения обусловлены разбиением общего графа, полученного на первом этапе алгоритма. 
<math>RI_{(C_{i},C_{j})} = \frac{2*|EC_{(C_{i},C_{j})}|}{|EC_{C_{i}}|+|EC_{C_{j}}|}</math> - относительная взаимная связность пары кластеров <math>C_{i}, C{j}</math> 
<math> RC_{(C_{i},C_{j})}= \frac{S_{EC_{(C_{i},C_{j})}}}{\frac{|C_{i}|}{|C_{i}+C_{j}|}*S_{EC_{(C_{i})}}+\frac{|C_{i}|}{|C_{i}+C_{j}|}*S_{EC_{(C_{j})}}}</math> - относительное взаимное сходство пары кластеров <math>C_{i}, C{j}</math> 

На основании этих показателей осуществляется агломеративная иерерхическая кластеризация. Существует две стратегии анализа показателей сходства. В первом случае для каждой пары кластеров <math>C{i}, C{j}</math> проверяется истинность выражений <math>RI_{(C_{i},C_{j})} >= T_{RI}</math> и <math>RC_{(C_{i},C_{j})} >= T_{RC}</math>, где <math>T_{RI}, T_{RI}</math> - заранее заданные пороговые значения. Если для некоторого <math>C_{i}</math> таких <math>C_{j}</math> несколько, то конкретная пара определяется по максимуму значения <math>EC_{(C_{i},C_{j})}</math>. Во втором случае выбираются пары кластеров, максимизирующие функцию вида <math>RI_{(C_{i},C_{j})}*RC_{(C_{i},C_{j})}^\alpha</math>. Здесь <math>\alpha</math> - заданный пользователем параметр. В обоих случаях процесс останавливается либо когда на очередной итерации не находится подходящих пар кластеров, либо когда остаётся только один кластер.

Вычисляемые данные: В процессе агломеративной кластеризации для всех объектов, т.е. всех вершин всех кластеров указывается индекс <math>j</math> кластера, к которому они принадлежат. После завершения алгоритма возможно перенумеровать кластеры. В любом случае на выходе будет иметься <math>n</math> значений, так как число объектов в процессе работы алгоритма не изменялось.

===Вычислительное ядро алгоритма===
В алгоритме 3 основных вычислительных ядра, по одному на каждый этап алгоритма.

На первом этапе алгоритма основная вычислительная нагрузка приходится на анализ матрицы смежности, необходимого для построения первоначального графа <math>G = (V, E)</math>, так как для каждого объекта необходимо перебрать всех его соседей и выделить <math>k</math> ближайших по заданной метрике.

На втором этапе наибольшее время занимает поиск подходящего разбиения очередного подграфа. В элементарном варианте этой процедуры необходимо перебрать все комбинации вершин в этом подграфе, удовлетворяющие условию 1) из математического описания алгоритма, и для каждой из них подсчитать значение, используемое в 2).

На третьем этапе алгоритма вычислительное ядро полностью совпадает с самим этапом, то есть итерационным процессов агломеративной иерархической кластеризации, включающем в себя подсчёт выбранной метрики для каждой пары кластеров, имеющихся на очередной итерации.

===Макроструктура алгоритма===
Как уже понятно из предыдущих разделов описания, алгоритм CHAMELEON выполняется в 3 этапа, последовательных относительно друг друга. Каждый этап, строго говоря, соответствует отдельному алгоритму. В рамках этого описания макрооперациями будут считаться процедуры разбиения наибольшего подграфа на каждой итерации второго этапа алгоритма, а также процедура вычисления метрики для принятия решения об объединении кластеров на каждой итерации третьего этапа.

===Схема реализации последовательного алгоритма===

Схема представлена в виде C++-подобного псевдокода, макрооперации в алгоритме выделены в соответствии с предыдущим разделом описания.

<source lang="C++">
// First stage.
int k // Number of neighbors.
float v[n][p] // Initial vectors.
float M[n][n] // Adjacency matrix.
for (int i = 0; i < n; ++i) {
for (int l = 0; l < n; ++l) {
M[i][l] = Compute_metric(v[i],v[l]);
}
}
Graph max_graph // Structure/class that represents a graph.
Neighbor_list list // Here neighbors are initially stored.
max_graph.add_vertices // Vertices ~ initial vectors.
for (int i = 0; i < n; ++i) {
for (int l = i + 1; i < n; ++i) { // "Smart" version - we do not repeat same vertex combinations.
if (neighbor_number < k) {
add_neighbor(v[i],v[l]) // Just add.
}else{
substitute_neighbor(v[i],v[l]) // Check whether a new element is closer than some of the oldies.
}
}
max_graph.add_neighbors // Looks at neighbor lists of current vector and adds them
}
</source>

<source lang="C++">
// Second stage.
float percent // Determines when to stop splitting graphs.
Graph graphs[n] // GRAPHS WILL MOST LIKELY TAKE LESS SPACE, IT'S JUST THE UPPER LIMIT.
max_graph = find_max_graph() // Biggest graph by number of vertices available.
while (graph_size(max_graph) > n * percent) {
Split_graph(max_graph); // Split the graph - a macro operation that represents the second phase.
}
</source>

<source lang="C++">
// Third stage.
Graph graphs[m] // That's how many graphs we got. m <= n.
bool pairs_exist // Check if the're pairs of clusters to unite.
while (num_graphs > 1 && pairs_exist){
pairs_exist = false // So we don't repeat if it fails.
for (int i = 0; i < m; ++i) {
for (int l = i + 1; l < m; ++l) { // Also a "Smart" version.
check_pair(pairs_exist, graphs[i], graphs[l]); // Check whether graphs are similar enough by some metrics.
if (pairs_exist) { Unite_graphs(graphs[i], graphs[l]) }; // Pairs_exist is set to true if something's found.
}
}
}
</source>

===Последовательная сложность алгоритма===

Общая временная сложность последовательного варианта алгоритма CHAMELEON определяется как <math>O(nm + nlog{n} + mlog{m})</math>, где <math>n</math> - число исходных объектов, <math>m</math> - число малых кластеров, полученных после первого этапа работы. В случае "предельного" разбиения <math>m = n</math> эта оценка превращается в <math>O(n^2)</math>. В любом случае эта оценка не учитывает необходимости построения матрицы смежности по исходному набору векторов (авторы оригинальной статьи в своих исследованиях подразумевают, что матрица смежности уже построена), что означает дополнительные <math>O(n^2)</math> операций. Тогда оценка будет составлять <math>O(n^2 + nm + nlog{n} + mlog{m})</math> операций или <math>O(n^2)</math> в случае "предельного" разбиения.
Следует также обратить внимание, что это оценка по числу не сложений и умножений, а достаточно крупных операций. Например, вычисление метрики между двумя векторами рассматривается как одна операция, а она включает в себя <math>n</math> умножений и <math>2n</math> сложений ( для вычисления квадратичной нормы разности векторов).

===Информационный граф===

Информационный граф дан в соответствии с макроструктурой алгоритма. Следует отметить, что имеются успешные попытки распараллелить 2 и 3 этапы алгоритма CHAMELEON ( см. раздел "Существующие реализации" ). Однако они включают в себя модификацию исходного алгоритма. Также возможно распараллеливание выборки пар кластеров и подсчёта их метрик внутри каждой из вершин stage_3_iter. Структура информационного графа внутри этих итераций аналогична структуре информационного графа первого этапа алгоритма.

[[File:CHAMELEON ruslanlazovskiy.png]]

===Ресурс параллелизма алгоритма===

Параллельную сложность алгоритма CHAMELEON следует оценивать отдельно для каждого этапа.
На первом этапе алгоритм поиска <math>k</math> ближайших соседей может быть выполнен за <math>n - 1</math> вычислений значения метрики между двумя векторами.
На втором этапе итерации алгоритма выполняются строго последовательно, а распараллеливание алгоритма внутри итерации не относится к теме статьи.
На третьем этапе итерации также выполняются последовательно, однако возможно распараллеливание обработки пар кластеров внутри итерации. Каждая итерация может быть выполнена за <math>q - 1</math> вычислений значения метрики между двумя кластерами, где q - количество кластеров на этой итерации.

===Входные и выходные данные алгоритма===

Входные данные:

<math>O</math> - набор из <math>n</math> векторов длины <math>p</math>. 
<math>k</math> - число, определяющиее количество ближайших соседей, по которым строится первоначальный граф. 

Выходные данные:

<math>B</math> - вектор длины <math>n</math>, значение <math>i</math>-го элемента указывает на принадлежность соответствующего вектора одному из кластеров.

===Свойства алгоритма===

Соотношение последовательной и параллельной сложности: Различные этапы алгоритма строго последовательны относительно друг друга. На первом этапе отношение последовательной сложности алгоритма к параллельной есть <math>n/2</math>. На втором и третьем этапах различные итерации последовательны относительно друг друга. Однако внутри итераций допускается некоторый параллелизм. Например, для итераций третьего этапа в наилучшем случае отношение сложности последовательной реализации к параллельной есть <math>q/2</math>, где <math>q</math> - число кластеров на конкретной итерации.

Вычислительная мощность: графовые алгоритмы, вообще говоря, обладают низкой вычислительной мощностью. В случае CHAMELEON вычислительная мощность первого этапа равна <math>O(1)</math>. Для второго и третьего этапов оценка вычислительной мощности по сложениям и умножениям затруднительна, однако в терминах макроопераций можно дать грубую оценку. Вычислительная мощность каждой итерации второго этапа - <math>1 / \sum C_n^k</math>, где <math>n</math> - число вершин в выбранном подграфе, а <math>k</math> варьируется от <math>0.25 * n</math> до <math>0.5 * n</math>. Вычислительная мощность каждой итерации третьего этапа в этих терминах - <math>O(1)</math>.

Детерминированность: Важной особенностью описываемого алгоритма является его недетерминированность. Условия завершения как 2-го, так и 3-го этапа позволяют обозначить CHAMELEON как итерационный алгоритм с выходом по точности. При этом детерминированность 2-го этапа алгоритма можно обеспечить указанием вырожденных условий кластеризации ( такая кластеризация, очевидно, не будет иметь практического смысла ), в то время как 2-ый этап является недетерминированным всегда.

==Программная реализация алгоритма==
===Особенности реализации последовательного алгоритма===
===Локальность данных и вычислений===
===Возможные способы и особенности параллельной реализации алгоритма===
===Масштабируемость алгоритма и его реализации===

Как можно увидеть из раздела "существующие реализации", параллельной реализации алгоритма CHAMELEON на система с распределенной памятью найдено не было. Однако в <ref>Parallel Algorithm for the Chameleon Clustering Algorithm using Dynamic Modeling. Rajnish Dashora, Harsh Bajaj, Akshat Dube, Geetha Mary .A. VIT University,Vellore. International Journal of Computer Applications (0975 – 8887) Volume 79 – No8, October 2013 </ref>. приводится экспериментальный вариант параллельной реализации посредством OpenMP для систем с общей памятью.

Основное внимание будет уделено исследованию масштабируемости алгоритма по размеру задачи, в пределах одного узла ( некоторый параллелизм достигается за счёт использования OpenMP ). Далее приводятся графики производительности в Гфлопс для различных размеров задачи. Эффективность работы алгоритма убывает на всей рассматриваемой области. Темпы убывания эффективности снижаются с ростом размера задачи.

[[File:CHAMELEON performance.png|800px]]

===Динамические характеристики и эффективность реализации алгоритма===
===Выводы для классов архитектур===
===Существующие реализации алгоритма===
С копией референсной реализации иерархической кластеризации, взятой с данного ресурса [http://us.codeforge.com/article/192925 Sequental], в случае неработоспособности последнего, можно ознакомиться здесь [http://pastebin.com/PhC4X0Cy Copy] 
Последовательная реализация алгоритма CHAMELEON использовалась в статье <ref>Clustering Of Web Usage Data Using
Chameleon Algorithm, T.Vijaya Kumar, Dr. H.S.Guruprasad, International Journal of Innovative Research in Computer
and Communication Engineering, Vol. 2, Issue 6, June 2014</ref>
Возможна реализация алгоритма CHAMELEON с использованием графовых библиотек, например [http://glaros.dtc.umn.edu/gkhome/metis/metis/overview METIS ], [http://glaros.dtc.umn.edu/gkhome/metis/hmetis/overview hMETIS] и [https://cran.r-project.org/web/packages/RANN/index.html RANN]. 
Параллельных реализаций алгоритма CHAMELEON в графовых библиотеках мною найдено не было. Однако существует исследование, связанное с реализацией CHAMELEON посредством технологии OpenMP, с которым можно ознакомиться здесь [http://research.ijcaonline.org/volume79/number8/pxc3891600.pdf параллельная реализация].

==Литература==

<references \>

Краткий обзор алгоритма [http://studopedia.ru/7_41934_algoritm-dinamicheskoy-ierarhicheskoy-klasterizatsii-CHAMELEON.html|] 
Первоначальная статья от авторов алгоритма [http://www-users.cs.umn.edu/~han/dmclass/chameleon.pdf|] 
Исследования возможной параллелизации алгоритма[http://research.ijcaonline.org/volume79/number8/pxc3891600.pdf|]

Обсуждение участника:ЕкатеринаКозырева

2016-11-16T11:07:02Z

Algoman:

Обсуждение участника:Артем Таран

2016-11-16T11:06:42Z

Algoman:

== Замечания к [[Участник:Артем_Таран/Графо-ориентированный_алгоритм_кластеризации_CHAMELEON]] ==

* отсутствует оценка вычислительной мощности алгоритма в п 1.10

* В п.1.1. следует добавить информацию о том, известно ли число кластеров заранее [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 16:26, 14 ноября 2016 (MSK)

* В п.1.2. наверное стоит отнести параметр k к исходным данным [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 16:26, 14 ноября 2016 (MSK)

== Замечания к пункту 2.4 от 16.11.2016 ==

* отсутствует пункт 2.4

Обсуждение участника:Steve/Графо-ориентированный алгоритм кластеризации CHAMELEON

2016-11-16T10:57:56Z

Algoman:

== Замечания к [[Участник:Steve/Графо-ориентированный_алгоритм_кластеризации_CHAMELEON]] ==

0) требуется указать вклад(пункты) каждого автора

1) отсутствует оценка вычислительной мощности алгоритма в п 1.10

2) пункты 2.1 и 2.2 должны быть 2.4 и 2.7, согласно формату описания [[Структура_описания_свойств_алгоритмов]]

3) список литературы оформлен неправильно - см. как сделано в [[Разложение_Холецкого_(метод_квадратного_корня)]]

== Замечания к пункту 2.4 от 16.11.2016 ==

* отсутствует пункт 2.4

Участник:Ruslanlazovskiy/CHAMELEON

2016-11-16T10:54:29Z

Algoman:

{{Assignment|Algoman}}

{{algorithm
| name = CHAMELEON
| serial_complexity = <math>O(n*m + n*log{n} + m*log{m})</math>
| pf_height = <math>O(n)</math> - этап 1. <math>O(q)</math> - отдельная итерация этапа 3.
| pf_width = <math>O(n)</math> - этап 1. <math>O(q)</math> - отдельная итерация этапа 3.
| input_data = <math>n^2 / 2</math>
| output_data = <math>n</math>
}}

Авторы статьи:
[https://algowiki-project.org/ru/%D0%A3%D1%87%D0%B0%D1%81%D1%82%D0%BD%D0%B8%D0%BA:Ruslanlazovskiy|Лазовский Р. А.] ( разделы 1.1 - 1.4 , 1.7 , 1.8 ),
[https://algowiki-project.org/ru/%D0%A3%D1%87%D0%B0%D1%81%D1%82%D0%BD%D0%B8%D0%BA:%D0%9C%D1%83%D1%81%D1%82%D0%B0%D1%84%D0%B0%D0%B5%D0%B2_%D0%AD%D0%BB%D1%8C%D0%B2%D0%B8%D0%BD_%D0%AD%D0%BB%D1%8C%D0%BC%D0%B0%D0%BD%D0%BE%D0%B2%D0%B8%D1%87|Мустафаев Э. Э.] ( разделы 1.5 , 1.6 , 1.9 , 1.10 , 2.2 )

==Свойства и структура алгоритма==
===Общее описание алгоритма===
CHAMELEON – алгоритм динамической иерархической кластеризации графа, то есть процесса разбиения графа на несколько подграфов-кластеров таким образом, что данные внутри одного кластера имеют максимально схожи, а данные в разных кластерах — максимально различны. В классических алгоритмах кластеризации схожесть объектов определяется с помощью некоторой метрики ( простейший пример - евклидова метрика ). Не следует путать задачу кластеризации с задачей классификации - в последней характеристики объекта, необходимые для попадания в тот или иной класс, известны заранее, в рассматриваемой же задаче они становятся известны в процессе решения. Первоначально алгоритм был описан в статье<ref>CHAMELEON: A Hierarchical Clustering Algorithm Using Dynamic Modeling. George Karypis, Eui-Hong Han, Vipin Kumar. IEEE Computer 32(8): 68-75, 1999</ref>.

Алгоритм CHAMELEON работает в 3 этапа. На первом этапе исходное множество объектов организуется в граф по принципу k ближайших соседей. На втором этапе этого граф разбивается на достаточно малые подграфы-кластеры. На третьем этапе происходит агломеративная иерархическая кластеризация полученных подграфов в соответствии с одной из выбранных метрик ( возможные метрики будут подробно описаны далее ). Число получаемых в итоге кластеров в явном виде не задаётся.

===Математическое описание алгоритма===

Исходные данные: Первоначально исходными данными алгоритма являются <math>n</math> векторов длины <math>p</math>, каждый из которых соответствует одному объекту. На основании значений элементов этих векторов строится матрица смежности размера <math>n * n</math> ( возможно сокращение требуемого объема памяти до <math>(n*(n - 1))/ 2</math> в соответствии с выбранной метрикой. К исходным данным также относится набор параметров. Это <math>k</math> - количество ближайших соседей на первом этапе алгоритма, <math>q</math> - отношение количества вершин в наибольшем подграфе по отношению к общему числу объектов на втором этапе алгоритма, а также параметры <math>T_{RI}, T_{RI}</math> - пороговые значения, после которых прекращается агломеративная кластеризация на третьем этапе. Следует особо отметить, что число получаемых в итоге кластеров заранее не известно, хотя на него и можно повлиять изменением значений перечисленных параметров.

Первый этап алгоритма: На первом этапе на основании матрицы смежности строится граф <math>G = (V, E)</math> <math>k</math> ближайших соседей, где <math>V</math> - множество вершин графа ( т.е. объекты ), а <math>E</math> - множество ребер графа ( т.е. построенные связи между ближайшими соседями ). Указанный граф не обязательно является связным.

Второй этап алгоритма: Граф <math>G = (V, E)</math> итеративно разбивается на множество подграфов <math>G_{i} = (V_{i}, E_{i}), i = 1 .. m</math>, где <math> \cup V_{i} = V, i = 1 .. m</math>. Параметр <math>m</math> явно не задаётся, выполнение этого этапа алгоритма прекращается по выполнении описанных далее условий. На каждой итерации выбирается <math>G_{b}</math> с числом вершин, наибольшим среди всех подграфов, имеющихся на данной итерации. Этот граф разбивается на 2 подграфа <math>G_{bi}</math> и <math>G_{bj}</math> таких, что 1) <math>min(V_{bi},V_{bj}) >= 0.25 * V_{b}</math> ( имеется ввиду количество вершин ) и 2) <math>\sum{E_{kl}}, E_{kl} = (v_{k}, v_{l}), v_{k} \in V_{bi} , v_{l} \in V_{bj} </math> минимальна среди всех разбиений, удовлетворяющих 1). Итеративный процесс прекращается, когда <math>\sum{v_{b}} <= q * \sum{v} , v_{b} \in V_{b} , e \in E</math> ( имеется ввиду количество вершин ). Здесь <math>q</math> - задаваемый параметр, на практике он варьируется от <math>0.01</math> до <math>0.05</math>. Полученные подграфы называются малыми кластерами.

Третий этап алгоритма: Множество кластеров <math>G_{i} = (V_{i}, E_{i}), i = 1 .. m</math> итеративно преобразуется в множество кластеров <math>G_{j} = (V_{j}, E_{j}), j = 1 .. l</math>, <math>l <= m</math>. Для этого вводятся следующие понятия:

<math>EC_{(C_{i},C_{j})}</math> - абсолютная взаимная связность пары кластеров <math>C_{i}, C{j}</math>. Это суть сумма весов ребер, соединяющих вершины, принадлежащие <math>C{i}</math> c вершинами из <math>C{j}</math>. <math>EC_{(C_{i},C_{i})}</math> вычисляется как сумма ребер, входящих в разделитель, разбивающий <math>C{i}</math> на два равных подграфа. 
<math>S_{EC_{(C_{i},C_{j})}}</math> - абсолютное взаимное сходство пары кластеров <math>C_{i}, C{j}</math>. Это суть среднее сходство между соединенными вершинами, принадлежащими <math>C{i}</math> и <math>C{j}</math> соответственно. Соединения обусловлены разбиением общего графа, полученного на первом этапе алгоритма. 
<math>RI_{(C_{i},C_{j})} = \frac{2*|EC_{(C_{i},C_{j})}|}{|EC_{C_{i}}|+|EC_{C_{j}}|}</math> - относительная взаимная связность пары кластеров <math>C_{i}, C{j}</math> 
<math> RC_{(C_{i},C_{j})}= \frac{S_{EC_{(C_{i},C_{j})}}}{\frac{|C_{i}|}{|C_{i}+C_{j}|}*S_{EC_{(C_{i})}}+\frac{|C_{i}|}{|C_{i}+C_{j}|}*S_{EC_{(C_{j})}}}</math> - относительное взаимное сходство пары кластеров <math>C_{i}, C{j}</math> 

На основании этих показателей осуществляется агломеративная иерерхическая кластеризация. Существует две стратегии анализа показателей сходства. В первом случае для каждой пары кластеров <math>C{i}, C{j}</math> проверяется истинность выражений <math>RI_{(C_{i},C_{j})} >= T_{RI}</math> и <math>RC_{(C_{i},C_{j})} >= T_{RC}</math>, где <math>T_{RI}, T_{RI}</math> - заранее заданные пороговые значения. Если для некоторого <math>C_{i}</math> таких <math>C_{j}</math> несколько, то конкретная пара определяется по максимуму значения <math>EC_{(C_{i},C_{j})}</math>. Во втором случае выбираются пары кластеров, максимизирующие функцию вида <math>RI_{(C_{i},C_{j})}*RC_{(C_{i},C_{j})}^\alpha</math>. Здесь <math>\alpha</math> - заданный пользователем параметр. В обоих случаях процесс останавливается либо когда на очередной итерации не находится подходящих пар кластеров, либо когда остаётся только один кластер.

Вычисляемые данные: В процессе агломеративной кластеризации для всех объектов, т.е. всех вершин всех кластеров указывается индекс <math>j</math> кластера, к которому они принадлежат. После завершения алгоритма возможно перенумеровать кластеры. В любом случае на выходе будет иметься <math>n</math> значений, так как число объектов в процессе работы алгоритма не изменялось.

===Вычислительное ядро алгоритма===
В алгоритме 3 основных вычислительных ядра, по одному на каждый этап алгоритма.

На первом этапе алгоритма основная вычислительная нагрузка приходится на анализ матрицы смежности, необходимого для построения первоначального графа <math>G = (V, E)</math>, так как для каждого объекта необходимо перебрать всех его соседей и выделить <math>k</math> ближайших по заданной метрике.

На втором этапе наибольшее время занимает поиск подходящего разбиения очередного подграфа. В элементарном варианте этой процедуры необходимо перебрать все комбинации вершин в этом подграфе, удовлетворяющие условию 1) из математического описания алгоритма, и для каждой из них подсчитать значение, используемое в 2).

На третьем этапе алгоритма вычислительное ядро полностью совпадает с самим этапом, то есть итерационным процессов агломеративной иерархической кластеризации, включающем в себя подсчёт выбранной метрики для каждой пары кластеров, имеющихся на очередной итерации.

===Макроструктура алгоритма===
Как уже понятно из предыдущих разделов описания, алгоритм CHAMELEON выполняется в 3 этапа, последовательных относительно друг друга. Каждый этап, строго говоря, соответствует отдельному алгоритму. В рамках этого описания макрооперациями будут считаться процедуры разбиения наибольшего подграфа на каждой итерации второго этапа алгоритма, а также процедура вычисления метрики для принятия решения об объединении кластеров на каждой итерации третьего этапа.

===Схема реализации последовательного алгоритма===

Схема представлена в виде C++-подобного псевдокода, макрооперации в алгоритме выделены в соответствии с предыдущим разделом описания.

<source lang="C++">
// First stage.
int k // Number of neighbors.
float v[n][p] // Initial vectors.
float M[n][n] // Adjacency matrix.
for (int i = 0; i < n; ++i) {
for (int l = 0; l < n; ++l) {
M[i][l] = Compute_metric(v[i],v[l]);
}
}
Graph max_graph // Structure/class that represents a graph.
Neighbor_list list // Here neighbors are initially stored.
max_graph.add_vertices // Vertices ~ initial vectors.
for (int i = 0; i < n; ++i) {
for (int l = i + 1; i < n; ++i) { // "Smart" version - we do not repeat same vertex combinations.
if (neighbor_number < k) {
add_neighbor(v[i],v[l]) // Just add.
}else{
substitute_neighbor(v[i],v[l]) // Check whether a new element is closer than some of the oldies.
}
}
max_graph.add_neighbors // Looks at neighbor lists of current vector and adds them
}
</source>

<source lang="C++">
// Second stage.
float percent // Determines when to stop splitting graphs.
Graph graphs[n] // GRAPHS WILL MOST LIKELY TAKE LESS SPACE, IT'S JUST THE UPPER LIMIT.
max_graph = find_max_graph() // Biggest graph by number of vertices available.
while (graph_size(max_graph) > n * percent) {
Split_graph(max_graph); // Split the graph - a macro operation that represents the second phase.
}
</source>

<source lang="C++">
// Third stage.
Graph graphs[m] // That's how many graphs we got. m <= n.
bool pairs_exist // Check if the're pairs of clusters to unite.
while (num_graphs > 1 && pairs_exist){
pairs_exist = false // So we don't repeat if it fails.
for (int i = 0; i < m; ++i) {
for (int l = i + 1; l < m; ++l) { // Also a "Smart" version.
check_pair(pairs_exist, graphs[i], graphs[l]); // Check whether graphs are similar enough by some metrics.
if (pairs_exist) { Unite_graphs(graphs[i], graphs[l]) }; // Pairs_exist is set to true if something's found.
}
}
}
</source>

===Последовательная сложность алгоритма===

Общая временная сложность последовательного варианта алгоритма CHAMELEON определяется как <math>O(nm + nlog{n} + mlog{m})</math>, где <math>n</math> - число исходных объектов, <math>m</math> - число малых кластеров, полученных после первого этапа работы. В случае "предельного" разбиения <math>m = n</math> эта оценка превращается в <math>O(n^2)</math>. В любом случае эта оценка не учитывает необходимости построения матрицы смежности по исходному набору векторов (авторы оригинальной статьи в своих исследованиях подразумевают, что матрица смежности уже построена), что означает дополнительные <math>O(n^2)</math> операций. Тогда оценка будет составлять <math>O(n^2 + nm + nlog{n} + mlog{m})</math> операций или <math>O(n^2)</math> в случае "предельного" разбиения.
Следует также обратить внимание, что это оценка по числу не сложений и умножений, а достаточно крупных операций. Например, вычисление метрики между двумя векторами рассматривается как одна операция, а она включает в себя <math>n</math> умножений и <math>2n</math> сложений ( для вычисления квадратичной нормы разности векторов).

===Информационный граф===

Информационный граф дан в соответствии с макроструктурой алгоритма. Следует отметить, что имеются успешные попытки распараллелить 2 и 3 этапы алгоритма CHAMELEON ( см. раздел "Существующие реализации" ). Однако они включают в себя модификацию исходного алгоритма. Также возможно распараллеливание выборки пар кластеров и подсчёта их метрик внутри каждой из вершин stage_3_iter. Структура информационного графа внутри этих итераций аналогична структуре информационного графа первого этапа алгоритма.

[[File:CHAMELEON ruslanlazovskiy.png]]

===Ресурс параллелизма алгоритма===

Параллельную сложность алгоритма CHAMELEON следует оценивать отдельно для каждого этапа.
На первом этапе алгоритм поиска <math>k</math> ближайших соседей может быть выполнен за <math>n - 1</math> вычислений значения метрики между двумя векторами.
На втором этапе итерации алгоритма выполняются строго последовательно, а распараллеливание алгоритма внутри итерации не относится к теме статьи.
На третьем этапе итерации также выполняются последовательно, однако возможно распараллеливание обработки пар кластеров внутри итерации. Каждая итерация может быть выполнена за <math>q - 1</math> вычислений значения метрики между двумя кластерами, где q - количество кластеров на этой итерации.

===Входные и выходные данные алгоритма===

Входные данные:

<math>O</math> - набор из <math>n</math> векторов длины <math>p</math>. 
<math>k</math> - число, определяющиее количество ближайших соседей, по которым строится первоначальный граф. 

Выходные данные:

<math>B</math> - вектор длины <math>n</math>, значение <math>i</math>-го элемента указывает на принадлежность соответствующего вектора одному из кластеров.

===Свойства алгоритма===

Соотношение последовательной и параллельной сложности: Различные этапы алгоритма строго последовательны относительно друг друга. На первом этапе отношение последовательной сложности алгоритма к параллельной есть <math>n/2</math>. На втором и третьем этапах различные итерации последовательны относительно друг друга. Однако внутри итераций допускается некоторый параллелизм. Например, для итераций третьего этапа в наилучшем случае отношение сложности последовательной реализации к параллельной есть <math>q/2</math>, где <math>q</math> - число кластеров на конкретной итерации.

Вычислительная мощность: графовые алгоритмы, вообще говоря, обладают низкой вычислительной мощностью. В случае CHAMELEON вычислительная мощность первого этапа равна <math>O(1)</math>. Для второго и третьего этапов оценка вычислительной мощности по сложениям и умножениям затруднительна, однако в терминах макроопераций можно дать грубую оценку. Вычислительная мощность каждой итерации второго этапа - <math>1 / \sum C_n^k</math>, где <math>n</math> - число вершин в выбранном подграфе, а <math>k</math> варьируется от <math>0.25 * n</math> до <math>0.5 * n</math>. Вычислительная мощность каждой итерации третьего этапа в этих терминах - <math>O(1)</math>.

Детерминированность: Важной особенностью описываемого алгоритма является его недетерминированность. Условия завершения как 2-го, так и 3-го этапа позволяют обозначить CHAMELEON как итерационный алгоритм с выходом по точности. При этом детерминированность 2-го этапа алгоритма можно обеспечить указанием вырожденных условий кластеризации ( такая кластеризация, очевидно, не будет иметь практического смысла ), в то время как 2-ый этап является недетерминированным всегда.

==Программная реализация алгоритма==
===Особенности реализации последовательного алгоритма===
===Локальность данных и вычислений===
===Возможные способы и особенности параллельной реализации алгоритма===
===Масштабируемость алгоритма и его реализации===

Как можно увидеть из раздела "существующие реализации", параллельной реализации алгоритма CHAMELEON на система с распределенной памятью найдено не было. Однако в <ref>Parallel Algorithm for the Chameleon Clustering Algorithm using Dynamic Modeling. Rajnish Dashora, Harsh Bajaj, Akshat Dube, Geetha Mary .A. VIT University,Vellore. International Journal of Computer Applications (0975 – 8887) Volume 79 – No8, October 2013 </ref>. приводится экспериментальный вариант параллельной реализации посредством OpenMP для систем с общей памятью.

Основное внимание будет уделено исследованию масштабируемости алгоритма по размеру задачи, в пределах одного узла ( некоторый параллелизм достигается за счёт использования OpenMP ). Далее приводятся графики производительности в Гфлопс для различных размеров задачи. Эффективность работы алгоритма убывает на всей рассматриваемой области. Темпы убывания эффективности снижаются с ростом размера задачи.

[[File:CHAMELEON performance.png|800px]]

===Динамические характеристики и эффективность реализации алгоритма===
===Выводы для классов архитектур===
===Существующие реализации алгоритма===
С копией референсной реализации иерархической кластеризации, взятой с данного ресурса [http://us.codeforge.com/article/192925 Sequental], в случае неработоспособности последнего, можно ознакомиться здесь [http://pastebin.com/PhC4X0Cy Copy] 
Последовательная реализация алгоритма CHAMELEON использовалась в статье <ref>Clustering Of Web Usage Data Using
Chameleon Algorithm, T.Vijaya Kumar, Dr. H.S.Guruprasad, International Journal of Innovative Research in Computer
and Communication Engineering, Vol. 2, Issue 6, June 2014</ref>
Возможна реализация алгоритма CHAMELEON с использованием графовых библиотек, например [http://glaros.dtc.umn.edu/gkhome/metis/metis/overview METIS ], [http://glaros.dtc.umn.edu/gkhome/metis/hmetis/overview hMETIS] и [https://cran.r-project.org/web/packages/RANN/index.html RANN]. 
Параллельных реализаций алгоритма CHAMELEON в графовых библиотеках мною найдено не было. Однако существует исследование, связанное с реализацией CHAMELEON посредством технологии OpenMP, с которым можно ознакомиться здесь [http://research.ijcaonline.org/volume79/number8/pxc3891600.pdf параллельная реализация].

==Литература==

<references \>

Краткий обзор алгоритма [http://studopedia.ru/7_41934_algoritm-dinamicheskoy-ierarhicheskoy-klasterizatsii-CHAMELEON.html|] 
Первоначальная статья от авторов алгоритма [http://www-users.cs.umn.edu/~han/dmclass/chameleon.pdf|] 
Исследования возможной параллелизации алгоритма[http://research.ijcaonline.org/volume79/number8/pxc3891600.pdf|]

Обсуждение участника:Ruslanlazovskiy

2016-11-16T10:54:03Z

Algoman:

== Замечания к [[Участник:Ruslanlazovskiy/CHAMELEON]] ==

1) все ссылки в статье не работают

2) список литературы оформлен неправильно - см. как сделано в [[Разложение_Холецкого_(метод_квадратного_корня)]]

3) для оформления (псевдо) кода следует использовать тег <nowiki><source lang="..."></nowiki>

== Мои правки ==

2) и 3) теперь сделаны как надо. В 1) не удалось поправить самую первую ссылку, ресурс с последовательной реализацией действительно умер.

== Замечания к статье про Хамелеон (ещё порция) ==

* Ссылки на авторов и список литературы - присоединяюсь к замечаниям. Список литературы действительно всего из одного наименования? [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 14:09, 14 ноября 2016 (MSK)

* В разделе 1 пояснить, нужно ли заранее знать число кластеров. Это неясно и из описания входных и выходных данных, должно же оно быть хоть где-нибудь [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 14:09, 14 ноября 2016 (MSK)

* Раздел 1.2. Когда вводим граф, желательно пояснить аргументы V и E в скобках. Аналогично с параметром m, который встречается впервые [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 14:09, 14 ноября 2016 (MSK)

* Раздел 1.6. Стоит сделать логарифм красивей [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 14:09, 14 ноября 2016 (MSK)

== Правки - порция 2. ==

* В список литературы добавлена статья с исследованием параллелизма. Остальные найденные статьи по Chameleon представляют собой кальку с оригинальной статьи ( первый пункт в списке ) в разделе описания алгоритма + описание задачи, для которой применялся алгоритм, для примера добавил одну из таких статей.
* Сделано
* Сделано
* Поправил, добавил описание "предельного" случая.

== Замечания к пункту 2.4 ==

* Отсутствуют подписи к меткам на оси числа процессов
* Желательно сделать крупнее размер шрифта подписей

Участник:Bagnikita/Face Recognition

2016-11-02T09:59:41Z

Algoman:

{{Assignment|Algoman}}

{{algorithm
| name = Распознавание лиц
| serial_complexity = <math>O(E(w,h,c)+n*d+n*logn+n*logk+CNNConst)</math>
| pf_height = <math>O(k)</math>
| pf_width = <math>O(n)</math>
| input_data = <math>w*h*c</math>
| output_data = <math>O(k)</math>
}}

Основные авторы описания: [[Участник:Bagnikita|Н.Ю.Багров]]

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===

Распознавание лиц при помощи компьютера было впервые предложено в 1966 г. Woody Bledsoe и др. В первой системе использовался графический планшет, на котором было необходимо вручную отметить ключевые особенности на лице (брови, губы и тд). Система в дальнешейм использовала расстояния между этими точками для сравнения разных изображений. Поскольку требовалось много ручной работы, то оператор мог обработать около 40 изображений в час. В 1997 была создана система, которая непосредственно работала с видеоданными и могла применяться на практике. В дальшейшем с увеличением производительности вычислительных систем появились более качественные алгоритмы, но они заметно уступали человеку на данной задаче. С появлением высокороизводительных видеокарт в 2014 году появились системы<ref>Taigman Y. et al. Deepface: Closing the gap to human-level performance in face verification //Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition. – 2014. – С. 1701-1708.</ref>, точность которых уже превышала точность оператора (человека). Основное преимущество таких систем в том, что они могут обрабатывать большие объемы данных - производительность человека намного ниже (требуется несколько секунд на сравнение пары изображений).

Задачу распознавания лиц можно разбить на несколько этапов:

* обучение нейронной сети
* построение биометрического шаблона
* сравнение биометрических шаблонов
* поиск в базе и формирование результата

=== Математическое описание алгоритма ===

Алгоритм состоит из построения биометрических шаблонов (дескрипторов) по изображению и поиску заданного шаблона в базе уже вычисленных дескрипторов.

В дальшейшем будем рассматривать только сверточные нейронные сети. Классические архитектуры нейронных сетей с полносвязными слоями неприменимы на практике для анализа изображений, поскольку количество параметров такой сети экспоненциально возрастает с размером входных данных и количеством слоев. В таких сетях каждый нейрон не связан со всеми нейронами предыдущего слоя, а домножается на некоторый коэффициент (ядро свертки) по всему изображению. Таким образом, каждый такой слой применяет операцию свертки ко входам со своими коэффициентами, что заметно уменьшает число весов в нейронной сети. Это позволяет уменьшить потребление памяти и эффект переобучения сети, который проявляется в том, что сеть хорошо работает на классификации элементов обучающей выборки и хуже на валидационной.

==== Обучение сверточной нейронной сети ====

Для обучения нейронной сети используется стохастический градиентный спуск. Начальные веса сети устанавливаются случайными. Заметим, что существенное время занимают сверточные и полносвязные слои. Их можно свести к операции перемножения матриц следуюим образом:
* пусть размерность фильтра свертки k*k
* скопируем блоки исходного изображения размером k*k в столбцы новой матрицы
* умножим эту матрицу на коэффициеты фильтра свертки
* полученная матрица будет результатом применения свертки к входному изображению

Сложность задачи вычисления свертки зависит квадратично от размера фильтра и линейно от количества выходных данных.

<math>FeatureMap = A^{n, w * h} * B^{w * h, c * k^2}</math>, где <math>FeatureMap</math> - результат применения свертки, а <math>A</math> и <math>B</math> - входное изображение и матрица весов слоя нейронной сети

Существуют библиотеки, например, NVIDIA cuDNN<ref>https://developer.nvidia.com/cudnn</ref>) которые решают данную задачу более эффективно. Например, свертки размером 3x3, 5x5 могут быть реализованы с использованием FFT (что работает на видеокарте быстрее, чем умножение матриц)

==== Построение биометрического шаблона ====

Будем называть биометрическим шаблоном вектор <math>{R}^d</math>, который является представлением лица человека. Этот вектор получается после применения нейронной сети к изображению - в качестве такого вектора используют отклики с одного последних слоев нейронной сети. Для обеспечения возможности сравнивать между собой эти шаблоны вектор нормализуют.

==== Сравнение биометрических шаблонов ====

На предыдущем этапе был получен вектор значений <math>D={A}^d</math>, где d - размерность дескриптора. Можно рассматривать достаточно много различных оценивающих функций (метриками их называть некорректно, т.к для них не всегда выполняется неравенство треугольника). Например, в качестве такой функции можно рассматривать cosine distance - косинус угла между векторами-признаками в d-мерном пространстве. Также достаточно часто используют L2 метрику, либо более сложные контрукции, такие как JointBayesian<ref>Chen D. et al. Bayesian face revisited: A joint formulation //European Conference on Computer Vision. – Springer Berlin Heidelberg, 2012. – С. 566-579.</ref>. У всех таких "метрик" есть преимущества и недостатки, например в L2 можно легко проводить кластеризацию, тогда как в JointBayes и cosine metric нет. JointBayes можно дообучить на целевой выборке и повысить точность работы алгоритма.

==== Поиск в базе и формирование результата ====

Предположим, что для каждого человека в базе есть несколько фотографий. Тогда после выполнения операции сравнения биометрических шаблона изображения-запроса <math>P</math> и всех изображений в базе <math>G={g1,g2,...,gn}</math> необходимо выбрать результат с максимальным значением оценивающей функции для данного человека. Т.е необходимо оставить в результате только уникальные по людям совпадения, выбрав при этом максимальное значение при удалении дубликатов по людям.

После выполнения поиска в базе необходимо произвести нормализацию полученных значений оценивающей функции. В системах распознавания лиц обычно используют диапазон [0.0 - 1.0], где 0.0 означает минимальное сходство двух изображений лиц, а 1.0 максимальное.

=== Вычислительное ядро алгоритма ===

Основные операции составляют построение биометрического шаблона, и поиск в базе

==== Построение биометрического шаблона ====

Обозначим за <math>E(w,h,c)</math> сложность операции вычисления биометричсекого шаблона по входному изображению лица человека. Поскольку сверточной нейронной сети с полносвязными слоями должно подаваться на вход изображения фиксированного размера, то необходимо изменить разрешение исходного изображения. В данной реализации алгоритма распознавания лиц используется билинейная интерполяция. Нейронная сеть получает на вход одноканальные изображения размером <math>100*100</math>. Поэтому число необходимых операций (по операциям умножения) можно оценить как <math>O(w*h*c) + O(100 * 100 * 6) = O(w*h*c) + Const</math>. На практике эта константа существенна, поскольку эти операции неоднородны по памяти.

Непосредственно время работы нейронной сети существенно зависит от предложенной архитектуры (глубины сети, типов слоев и числа выходов каждого слоя).

В реализации, предлолженной в практической части, используются более 10 сверточных слоев. Количестве операций можно оценить исходя из количества весов связей в нейронной сети - 80M и размера сверток <math>3*3</math>. Оценка числа операций получилась ~2 GFlops на одну операцию применения нейросети (forward pass, 180ms). Она согласуется с реальным временем работы системы и производительностью системы на тесте linpack (130GFlops 4 cores) на ноутбуке.

==== Поиск в базе ====

Поиск в базе состоит из следующих частей:
* сравнение между собой двух дескрипторов изображений и вычисление метрики по базе
* агрегация результатов по людям
* сортировка по убыванию метрики сходства двух изображений

===== Сравнение между собой двух дескрипторов изображений и вычисление метрики по базе =====

В практической реализации алгоритма используется косинусовая метрика <math>M(x,y)=\frac{(x,y)}{\lVert x \lVert * \lVert y \lVert}</math>. Заметим, что вектора <math>x, y</math> уже нормированы на предыдущем этапе. Поэтому число операций для вычисления метрики составляет <math>d</math> умножений и <math>d - 1</math> сложений, где d - размерность дескриптора. Если размер базы <math>n</math>, то число операций <math>O(n*d+n*(d-1))=O(n*d)</math>.

===== Агрегация результатов по людям =====

Для выполнения операции unique (без использования дополнительной памяти) необходимо отсортировать элементы (person_id, match_score) массива по ключу person_id, а при совпадении по score. После этого можно за линейное время удалить дубликаты по person_id, оставив первый элемент (который будет максимальным по match_score). Сложность таких операций <math>O(n*logn+n)=O(n*logn)</math>.

===== Cортировка по убыванию метрики сходства двух изображений =====

Финальная сортировка по match_score будет выполнена за O(n*logk), где k - количество результатов в выдаче. Обычно на практике число k не более 1000, поскольку обработка результата чаще всего производится вручную оператором (человеком).

=== Макроструктура алгоритма ===

Алгоритм содержит вычисление биометричиского шаблона, который на этой странице не приводится. Используется готовая бибилотека распознавания лиц [http://tevian.ru Tevian FaceSDK]. Предложенная параллельная реализация может работать с любой системой распознавания лиц, для которой выполнены следующие условия:
* известна метрика для сравнения
* можно получить дескрипторы (биометрические шаблоны) в явном виде

Основная вычислительная сложность алгоритма связана с вычислением скалярных произведений и удалением повторных сопоставнений людей с выбором максимума.

=== Схема реализации последовательного алгоритма ===

Алгоритм можно представить в виде следующего фрагмента псевдокода (он менее эффективный, чем предложенный выше. Эффективная реализация на c++):

<source lang='python'>
desc = enroll(Image) # Image - изображение лица человека
matches = {}
for gallery_entry in G:
if matches.get(gallery_entry.person_id, None) is None:
matches[gallery_entry.person_id] = 0.0
matches[gallery_entry.person_id] = max(matches[gallery_entry.person_id], match(desc, gallery_entry.descriptor))
matches = sorted(key = lambda x: x[1], matches.items())
return [x[0], applyMapping(x[1]) for x in matches]
</source>

=== Последовательная сложность алгоритма ===

Если рассматривать всю последовательность действий (построение шаблона, поиск в базе), то сложность алгоритма <math>O(E(w,h,c)+n*d+n*logn+n*logk+CNNConst)</math>, где
*<math>n</math> - число элементов в базе
*<math>d</math> - размерность биометрического шаблона
*<math>E(w,h,c)</math> - сложность обработки изображения размером (width*height*channels) до необходимого размера для нейросети
*<math>n*d</math> - число операций для вычисления метрики между запросом и базой
*<math>n*logn</math> - сортировка результата для удаления дубликатов
*<math>n*logk</math> - сортировка результата по значению оценивающей функции

=== Информационный граф ===

На первом шаге необходимо построить биометрический шаблон - поскольку внути алгоритма используется нейросеть, то эти вычисления обычно выполняются на видеокартах. В этом разделе подробно не рассматривается работа нейросети, поэтому можно считать, что ему соответствует одна вершина в графе.

На втором шаге уже есть посчитанный биометрический шаблон (дескриптор) - его необходимо сопоставить в базой (пусть в ней N дескрипторов). Предположим, что доступно Q исполнителей (процессов или потоков). Тогда возможна паралельная обработка Q диапазонов базы размером N/Q. Для каждого такого вычисления длина последовательной части <math>N/Q*d</math>, где d - размерность дескриптора.

На третьем шаге производится агрегация полученных результатов сопоставнения длины k с один общий список, отсортированный по убыванию меры сходства изображений. Здесь аналогично можно рассматривать параллельную сортировку на Q вычислителях.

Видно, что у алгоритма большой ресурс по возможности распараллеливания за счет возможности параллельной реализации практически любой его части.

[[Файл:Facerecognition-graph.png|thumb|center|700px|Рисунок 0. Граф параллельного алгоритма]]

=== Ресурс параллелизма алгоритма ===

Сложность параллельного алгоритма, в предположении доступности q узлов: <math>O(k*logk+q*(log(k*q))^2+\frac{n}{q}*(d+log(\frac{n}{q}))+\lambda*(k*log(q)+q*(log(q*k))^2))</math>, где
* n - размер базы изображений лиц
* d - размерность биометрического шаблона
* k - количество результатов в выдаче (k << n)
* <math>\lambda</math> - флаг (0 или 1), нужно ли производить агрегацию результатов по людям

Данная оценка получена с применением [http://darwin.bth.rwth-aachen.de/opus3/volltexte/2010/3502/pdf/3502.pdf параллельной сортировки].

=== Входные и выходные данные алгоритма ===

Входные данные:
* изображение <math>P\in{R}^{w*h*c}</math>, где w,h,c - ширина, высота, число каналов
* база изображений лиц <math>G={g_1,g_2,g_3,...,g_n}, g_i\in{T}</math>
* T - объект, состоящий из биометрического шаблона и порядкового номера человека

Выходные данные*
* список <math>L={l_1,l_2,...,l_k}</math>, где <math>l_i\in{T}</math>
* T - объект, состоящий из числа (мера сходства двух изображений) и id (порядкового номера) человека в базе

=== Свойства алгоритма ===

Основная проблема при реализации параллельной версии данного алгоритма - необходимость сортировки результатов. Исходя из размеров базы важно правильно выбрать количество вычислителей, поскольку в ряде случаев сортировка будет работать очень быстро (число элементов будет значительно меньше объема базы) и не потребуется реализация параллельной сортировки.

Другая проблема - низкая вычислительная сложность самого алгоритма и большое число обращений к памяти. При реализации важно выделять память большими блоками для успешного чтения из кэша процессора.

Из преимуществ данного алгоритма можно назвать низкую нагрузку на сеть при обмене данными, возможность работы на множестве систем (MPI, hadoop и тд), посколько объем данных, передаваемых между узлами небольшой. Для практической реализации не требуется использования специальных коммуникаций с низкой задержкой (обмены происходят достаточно редко, время доставки сообщений не критично).

== Программная реализация алгоритма ==

Построение биометрических шаблонов выполнено при помощи библиотеки распознавания лиц Tevian FaceSDK<ref>http://tevian.ru/product/facesdk</ref>. В этом разделе приводится эффективность параллельной реализации сравнения изображени лица с некоторой базой лиц.

=== Особенности реализации последовательного алгоритма ===

В текущей версии алгоритма применяется векторизация с использованием FMA3 инструкций, что позволяет значительно ускорить работу программы. При выполнении оценки производительности системы использовалась простая реализация cosine метрики (цикл для вычисления скалярного произведения) и с использованием FMA инстукций.

Псевдокод операции mm256_fmadd (intel)

<source lang="fortran">
FOR j := 0 to 7
i := j*32
dst[i+31:i] := (a[i+31:i] * b[i+31:i]) + c[i+31:i]
ENDFOR
dst[MAX:256] := 0
</source>

В результате тестирования (процессор 6300HQ, ноутбук, база 30М биометрических шаблонов) однопоточной программы было установлено, что FMA3 версия в 5 раз быстрее по сравнению с обычным циклом (880ms vs 4600ms). Все дальнейшие экспериенты будут проводиться с FMA3 реализацией (если не указано иначе). Компиляция производится gcc 5.4 с флагами <code>-O3 -static-libgcc -static-libstdc++ -mavx -mavx2 -mfma -fopenmp</code>

Ниже приводится пример кода для вычисления дескриптора:
<source lang="c++">
pp = descriptor;
pg = gallery_ptr;
__m256 sum = _mm256_setzero_ps();
for(int j = 0; j < 16; ++j, pp += 8, pg += 8) {
sum = _mm256_fmadd_ps(_mm256_load_ps(pp), _mm256_load_ps(pg), sum);
}
const __m128 x128 = _mm_add_ps(_mm256_extractf128_ps(sum, 1), _mm256_castps256_ps128(sum));
const __m128 x64 = _mm_add_ps(x128, _mm_movehl_ps(x128, x128));
const __m128 x32 = _mm_add_ss(x64, _mm_shuffle_ps(x64, x64, 0x55));
score = _mm_cvtss_f32(x32);
</source>

Для сортировки результатов и агрегации по людям используются функции из stl - вполне возможно, что можно реализовать более эффективно.

=== Локальность данных и вычислений ===

Данный алгоритм производит вычисления скалярных произведений, поэтому на этом этапе все обращения к памяти обладают свойством локальности. Биометрический шаблон полностью помещается в кэш память любого современного процессора, данные под базу изобрежний выделяются в виде больших непрерывных блоков памяти.

Сортировка результатов также обладает свойством локальности, поскольку массив хранится непрерывно в памяти. При небольшом размере базы (1-10M изображений) он может полностью поместиться в кэш памяти.

=== Возможные способы и особенности параллельной реализации алгоритма ===

Алгоритм построен по модели map/reduce. В map происходит вычисление скалярных произведений дескриптора-запроса и элементов базы. В reduce происходит сортировка и удаление повторов.

Исходная база разбирается на блоки (chunks) по 1M биометрических шаблонов, каждый такой блок обрабатывается независимо в своем потоке (или процессе). Важно то, что в результате работы алгоритма на каждом блоке в результате получается небольшой объем данных - <math>k*(sizeof(float)+sizeof(int32_t))</math>. Такие данные можно легко передать по медленному каналу с высокой задержкой (не требуется использование InfiniBand). Также данный алгоритм можно запускать как на MPI кластерах с передачей сообщений, так и на hadoop кластерах.

Для сортировки результатов можно применять параллельную сортировку (которая ассимптотически) лучше, но на практике это не нужно из-за разумного ограчения на число результатов. Часто их просматривает вручную оператор системы, поэтому больше нескольких тысяч ставить бессмысленно.

В текущей версии системы реализован параллелизм с использованием OpenMP. Вместо OpenMP можно использовать любой метод многопоточной обработки данных, например, pthread. Сложность модификации кода минимальна, поскольку map/reduce подразумевает отсутствие зависимостей между различными блоками.

При реализации распределенной системы можно размещать разные chunks на вычислительных узлах и агрегировать результаты. Из-за небольшого размера сообщений такую систему можно легко построить в ЦОД без использования специальных коммуникаций на обычных серверах.

CUDA можно применять на этапе построения биометрического шаблона, что позволит значительно ускорить построение дескрипторов (например, во время добавления в базу большого числа изображений новых людей).

=== Масштабируемость алгоритма и его реализации ===

В дальнейшем во всех тестах будет использоваться сервер с 2x E5-2683v3 128GB RAM. MOPS - миллионы операций (для map -скалярное произведение, reduce - сортировка) в секунду.

Каждый тест проводится 20 раз, результаты усредняются.

[[Файл:Facerecognition-matcher.png|thumb|center|700px|Рисунок 1. Результаты работы map функции в зависимости от размера базы и числа потоков в openmp]]

Т.к скорость чтения из DDR4 памяти 17GB/s (на практике немного меньше), то с 4 каналов памяти (по 2 на каждый процессор) нельзя считывать быстрее, чем 68GB/s. База 200M дескрипторов занимает 98GB ram, поэтому время 2300ms для вычисления всех скалярных произведений близко к нижней границе. Дальнейшее увеличение числа потоков на одном сервере не будет приводить к существенному ускорению работы программы.

Результаты работы reduce функции в завсимости от размера базы и числа потоков в openmp:
[[Файл:Facerecognition_reduce.png|thumb|center|700px|Рисунок 2. Результаты работы reduce функции в зависимости от размера базы и числа потоков в openmp]]

Reduce этап лучше распараллеливается, поскольку в нем намного меньше число обращений к памяти. Его также можно ускорять, например подбирая оптимальный размер блока (chunk size). Для базы в 200M лиц лучшая скорость 1400ms (достигается на 20 потоках, дальше ускорения нет).

Значительное ускорение при размере базы в 100M (значение близко к 64GB) возникает предположительно из-за использование памяти второго процессора (суммарно 4 канала памяти, а не 2).

[[Файл:Facerecognition_overall.png|thumb|center|700px|Рисунок 3. Суммарная скорость работы системы в зависимости от размера базы и числа потоков в openmp]]

==== Исследование влияния HyperThreading на работу алгоритма ====

Поскольку могут возникать проблемы из-за низкой пропускной способности памяти, можно предположить, что HyperThreading позволит ускорить работу программы. Во время ожидания данных из памяти может быть задействован второй вычислитель в ядре.

Синяя точка на графике - лучший результат c HyperThreading, красная - HyperThreading выключен.

[[Файл:Facerecognition-ht-matcher.png|thumb|center|700px|Рисунок 4. Результаты работы map функции в зависимости от размера базы и числа потоков в openmp (10-56 потоков)]]

[[Файл:Facerecognition-ht-reduce.png|thumb|center|700px|Рисунок 5. Результаты работы reduce функции в зависимости от размера базы и числа потоков в openmp (10-56 потоков)]]

[[Файл:Facerecognition-ht-overall.png|thumb|center|700px|Рисунок 6. Суммарная скорость работы системы в зависимости от размера базы и числа потоков в openmp (10-56 потоков)]]

Видно, что включение HyperThreading повышает производительность системы. Для reduce шага это ускорение значительно.

=== Динамические характеристики и эффективность реализации алгоритма ===

Эксперименты проводились на сервере с 2x E5-2683v3 128GB RAM.

Для семейства процессоров на ядре haswell возможно выполнение 32 операций умножения+сложения за такт.

Поэтому пиковая производительность <math>Rpeak=2*14*32*2.0*10^9</math>, где
* 2 - число процессоров
* 14 - количество ядер на каждом из процессоров
* 32 - количество операций за такт
* <math>2.0*10^9</math> - частота ядра без turbo boost

FLOPS алгоритма <math>k=100*10^6*128*2</math>, где
* <math>100*10^6</math> - число операций в секунду
* 128*2 - количество действий, необходимых для проведения одного сравнения

Эффективность для map = k / peak = 0.014 (1.42%)

=== Выводы для классов архитектур ===

Данный алгоритм должен хорошо работать как на суперкомпьютерах со специализированной сетевой частью, так и на кластерах серверов с 1/10G Ethernet за счет низкой частоты обменов. Также при необходимость его можно использовать на мобильных рабочих станциях (ноутбуках) и специализированных серверах (4x xeon E7-8XXX), которые смогут обрабатывать в реальном времени большие объемы данных (например, биометрические для всех людей в стране).

=== Существующие реализации алгоритма ===

Системы распознавания лиц редко бывают открытыми (или они низкого качества), поэтому известных распределенных систем распознавания лиц мало. Такие системы часто создаются под отдельный проект и их нельзя купить как "коробочное" решение.

== Литература ==

[[Категория:Нейронные сети]]

Участник:Артем Таран/Графо-ориентированный алгоритм кластеризации CHAMELEON

2016-11-01T11:48:54Z

Algoman:

{{Assignment|Algoman}}

{{algorithm
| name = Графо-ориентированный алгоритм кластеризации CHAMELEON
| serial_complexity = <math>O(n^2+nm+m^2log(m))</math>
| pf_height = <math>O(n + log(n) + mlog(m) + m^2log(m))</math>
| pf_width = <math>O(n)</math>
| input_data = <math>\frac{n (n - 1)}{2}</math>
| output_data = <math>n</math>
}}

Статью подготовили: [[Участник:Артем_Таран|Артём Таран Иванович]] (разделы 1.1 - 1.10, 2.7), [[Участник:ShimchikN|Шимчик Никита Владимирович]] (разделы 1.1 - 1.10, 2.7).
== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===

Кластеризация — многомерная статистическая процедура, выполняющая сбор данных, содержащих информацию о выборке объектов, и затем упорядочивающая объекты в сравнительно однородные группы (кластеры) с минимизацией межкластерного сходства и максимизацией внутрикластерного сходства.

Графо-ориентированный алгоритм кластеризации CHAMELEON<ref name="rt">http://www-users.cs.umn.edu/~han/dmclass/chameleon.pdf</ref> - алгоритм, который измеряет сходство двух кластеров на основе
динамической модели. В процессе кластеризации два кластера объединяются, только если показатели взаимосвязанности и близости между двумя кластерами являются высокими по отношению к показателям внутренней взаимосвязанности кластеров и близости элементов внутри этих кластеров. Процесс слияния с использованием динамической модели, использующийся в данном алгоритме облегчает открытие
природных и однородных кластеров. Методология динамического моделирования кластеров, использующаяся в CHAMELEON,
применима ко всем типам данных, для которых может быть построена матрица подобия.

Алгоритм кластеризации CHAMELEON включает в себя три этапа:

1) Построение графа, путём добавления рёбер по принципу k ближайших соседей.

2) Выделение множества сравнительно малых связных подграфов.

3) Формирование набора кластеров, на основе множества подграфов, полученных на предыдущем этапе.

[[Файл:Графы k ближайших соседей.jpg|1000px|thumb|center|Графы k ближайших соседей: 1) объекты в пространстве, 2) граф по принципу 1-го ближайшего соседа, 3) граф по принципу 2-го ближайшего соседа, 4) граф по принципу 3-х ближайших соседей<ref name="rt">http://www-users.cs.umn.edu/~han/dmclass/chameleon.pdf</ref>]]

=== Математическое описание алгоритма ===
==== Данные ====
* '''Исходные данные''': множество из <math>n</math> точек <math>V = \{v_{i}\}</math> в метрическом пространстве, которое может быть задано в виде треугольной матрицы расстояний <math>A</math> размера <math>n\times n</math>.

* '''Промежуточный результат после первого этапа''': граф <math>G = (V, E)</math>, полученный путём соединения каждой точки с её <math>k</math> ближайшими соседями.

* '''Промежуточный результат после второго этапа''': разбиение множества <math>V</math> на набор <math>K = \{K_{i}\}</math> попарно непересекающихся связных подмножеств, из которого образуется взвешенный граф <math>G_{2} = (K, E_{2})</math>.

* '''Промежуточный результат после третьего этапа''': итоговое разбиение множества вершин графа <math>G_{2}</math> на набор кластеров <math>C = \{C_{i}\}</math>.

* '''Вычисляемые данные''': n-мерный вектор <math>v</math> (элементы <math>v_{i}</math>), показывающий отображение исходного множества точек на набор кластеров <math>C</math>.

==== Определения ====

* ''Абсолютная взаимная связность между парой кластеров <math>C_{i}</math> и <math>C_{j}</math>'' определяется как сумма весов ребер, соединяющих вершины, принадлежащие <math>C_{i}</math> с вершинами из <math>C_{j}</math>. Эти ребра, фактически, входят в разделитель ребер графа, состоящего из кластеров <math>C_{i}</math> и <math>C_{j}</math>, и разбивающим его на подграфы <math>C_{i}</math> и <math>C_{j}</math>. Обозначается эта величина как
<math>EC_{(C_{i},C_{j})}</math>. Внутреннюю связность <math>EC_{C_{i}}</math> кластера <math>C_{i}</math> можно вычислить как сумму ребер, входящих в разделитель ребер, разбивающий <math>C_{i}</math> на два совершенно равных подграфа.

* ''Относительная взаимная <math>RI_{(C_{i},C_{j})}</math> связность пары кластеров <math>C_{i}</math> и <math>C_{j}</math>'' определяется формулой:

<math>RI_{(C_{i},C_{j})} = \frac{2*|EC_{(C_{i},C_{j})}|}{|EC_{C_{i}}|+|EC_{C_{j}}|}</math>

Учитывая значения относительной взаимной связности, можно добиться получения кластеров разного размера, формы и плотности, то есть общего внутреннего сходства.

* ''Абсолютное взаимное сходство между парой кластеров <math>C_{i}</math> и <math>C_{j}</math>'' подсчитывается как среднее сходство между соединенными вершинами, принадлежащими <math>C_{i}</math> и <math>C_{j}</math> соответственно. Эти соединения обусловлены предыдущим разбиением общего графа, полученного на матрице сходства.

* ''Относительное взаимное сходство <math>RC_{(C_{i},C_{j})}</math> между парой кластеров <math>C_{i}</math> и <math>C_{j}</math>'' определяется как абсолютное сходство между этой парой кластеров, нормализованное с учетом их внутреннего сходства и вычисляется по формуле:

<math> RC_{(C_{i},C_{j})}= \frac{S_{EC_{(C_{i},C_{j})}}}{\frac{|C_{i}|}{|C_{i}+C_{j}|}*S_{EC_{(C_{i})}}+\frac{|C_{i}|}{|C_{i}+C_{j}|}*S_{EC_{(C_{j})}}}</math>,

где <math>S_{EC_{(C_{i})}}</math> и <math>S_{EC_{(C_{i})}}</math> - средние веса ребер (значения сходства), принадлежащих разделителю ребер кластеров <math>C_{i}</math> и <math>C_{j}</math> соответственно,
и <math>S_{EC_{(C_{i},C_{j})}}</math> - средний вес ребер, соединяющих вершины <math>C_{i}</math> с вершинами <math>C_{j}</math>, причем ребра принадлежат разделителю ребер <math>EC_{(C_{i})}</math>, определенному ранее.

Далее, алгоритм применяет агломеративную иерархическую кластеризацию с использованием вышеозначенных показателей. Причем существует две стратегии их учета. Первая подразумевает наличие некоторых пороговых значений <math>T_{RI}</math> и <math>T_{RC}</math>. В соответствии с этой стратегией, алгоритм для каждого кластера <math>C_{i}</math> проверяет, отвечают ли смежные (наиболее близкие) ему кластеры условиям:

*<math>RI_{(C_{i},C_{j})} \geqslant T_{RI}</math>

*<math>RC_{(C_{i},C_{j})} \geqslant T_{RC}</math>

Если более одного смежного кластера отвечает этим условиям, то алгоритм выбирает для объединения наиболее связный кластер (граф), то есть такой кластер <math>C_{j}</math>, с которым у кластера <math>C_{i}</math> получается наибольшая абсолютная взаимная связность. По завершению прохода по всем кластерам, созданные таким образом пары объединяются. Параметры <math>T_{RI}</math> и <math>T_{RC}</math> могут использоваться для изменения характеристик получаемых кластеров.

Вторая стратегия заключается в использовании специальной функции, объединяющей понятия относительной взаимной связности и относительного взаимного сходства. На каждом шаге выбираются те кластеры для объединения, которые максимизируют эту функцию:

<math>RI_{(C_{i},C_{j})}*RC_{(C_{i},C_{j})}^\alpha</math>,

где <math>\alpha</math> выбирается пользователем. Если <math>\alpha > 1 </math>, то алгоритм придает большее значение относительному взаимному сходству, а если <math>\alpha < 1 </math>, то большее значение имеет относительная взаимная связность. Разумеется, данный подход позволяет получить полную дендрограмму кластерного анализа<ref name="rty">http://studopedia.ru/7_41934_algoritm-dinamicheskoy-ierarhicheskoy-klasterizatsii-CHAMELEON.html</ref>.

=== Вычислительное ядро алгоритма ===

На первом этапе работы алгоритма вычислительным ядром можно считать процесс нахождения k ближайших соседей для каждой отдельной вершины.

На втором этапе работы алгоритма вычислительным ядром является поиск разбиения графа на два подграфа с минимизацией разделителя рёбер графа.

На третьем этапе работы алгоритма вычислительным ядром является расчёт <math>EC_{(C_{i},C_{j})}</math>, <math>RC_{(C_{i},C_{j})}</math> и <math>RI_{(C_{i},C_{j})}</math> для пары смежных кластеров, а также их слияние.

=== Макроструктура алгоритма ===

Алгоритм CHAMELEON выполняется в 3 этапа, последовательных относительно друг друга. Каждый этап соответствует отдельному алгоритму.

* Макрооперацией на первом этапе является процедура выделения k ближайших соседей.

* Макрооперацией на втором этапе является процедура разбиения наибольшего подграфа на каждой итерации.

* Макрооперациями на третьем этапе являются процедуры вычисления метрики для принятия решения об объединении кластеров и объединение кластеров на каждой итерации.

=== Схема реализации последовательного алгоритма ===

* Первый этап (псевдокод):
integer n; // Количество точек.
integer k; // Параметр k
integer A[n][n]; // Верхняя треугольная матрица расстояний между точками.

integer E[n][n]; // Верхняя треугольная матрица рёбер графа G - изначально инициализирована нулями.
foreach (integer i in (1,n-1) ) {
integer Neighbors[k]; // матрица, используемая хранения ближайших соседей
integer countN = 0;

foreach (integer j in (i+1, n) ) {
// Заполняем матрицу Neighbors, добавляя новые элементы и увеличивая счётчик countN.
// Когда countN станет равен k, новые элементы будут вставляться на место старых, либо отбрасываться.
}

foreach (integer j in (0, countN) ) {
E[min(i,j), max(i,j)] = 1;
}
}
return E;

* Второй этап:
[[File:Диаграмма_шаг_2.png]]

* Третий этап:
[[File:Chameleon_stage_3.png|611px]]

=== Последовательная сложность алгоритма ===
1) Построение графа на основе метода k ближайших соседей в худшем случае требует <math>O(n^2)</math> операций;

2) Для выделения множества сравнительно малых связных подграфов требуется <math>nm</math> операций;

3) Формирование набора кластеров, на основе множества подграфов, полученных на предыдущем этапе, требует <math>m^2log(m)</math> операций.

Итого, получаем последовательную сложность <math>O(n^2+nm+m^2log(m))</math>.

=== Информационный граф ===

[[File:Chameleon_inforgraph.png|811px]]

=== Ресурс параллелизма алгоритма ===

Первый этап работы алгоритма можно распределить между <math>n</math> процессами: в этом случае каждому процессу назначается своя точка и происходит поиск <math>k</math> ближайших соседей. Таким образом, его параллельная сложность составляет <math>O(n)</math>.

На втором этапе количество задействованных процессов может варьироваться в зависимости от входных данных. В худшем случае число итераций можно оценить как <math>O(log(n))</math>.

На третьем этапе можно распараллелить процесс расчёта метрик сходства между кластерами, однако итоговое слияние всё равно должно выполняться последовательно.
Поскольку процесс сравнения кластеров возможно распараллелить, сложность 3-го этапа составляет <math>mlog(m) + m^2log(m)</math>.

Таким образом, суммарная параллельная сложность оказывается равна <math>O(n + log(n) + mlog(m) + m^2log(m))</math>.

=== Входные и выходные данные алгоритма ===

* Входные данные:

1) Треугольная матрица <math>A</math> размера <math>n\times n</math> (где n — количество объектов), в которой элементу <math>a_{ij}</math> соответствует расстояние между i-м и j-м объектами.

2) Количество ближайших соседей <math>k</math> для вершин (рекомендуемое значение <math>k</math> от 5 до 20 в зависимости от количества анализируемых объектов).

3) Наименьшее число вершин, которое может содержать наибольший подграф на 2-м этапе <math>l</math>. Величина этого параметра варьируется от 1 до 5 % от общего числа объектов.

* Объём входных данных: <math>\frac{n (n - 1)}{2}</math>

* Выходные данные: n-мерный вектор <math>v</math>, в котором элементу <math>v_{i}</math> соответствует номер кластера, присвоенный i-му объекту

* Объём выходных данных: <math>n</math>

=== Свойства алгоритма ===

Первый этап алгоритма обладает хорошим ресурсом параллелизма: параллельная сложность его выполнения составляет <math>O(n)</math>, что намного лучше последовательной оценки <math>O(n^2)</math>.

У второго и третьего этапов алгоритма сложно полностью оценить ресурсы параллелизма. Но оба этапа возможно частично распараллелить.

'''Вычислительную мощность''' для разных этапов алгоритма можно оценить как:

1 этап: <math>O(1)</math>

2 этап: <math>O(\frac{nm}{n^2+m^2})</math>

3 этап: <math>O(\frac{m^2log(m)}{m^2+n})</math>

Детерминированность: Важной особенностью данного алгоритма является его недетерминированность. Несмотря на то, что 1-й этап детерминирован, алгоритм в целом является недетерминированным, так как на 2-ом этапе могут быть найдены различные разбиения на подграфы, а это повлияет и на итоговый результат работы алгоритма.

== Программная реализация алгоритма ==

=== Особенности реализации последовательного алгоритма ===

=== Локальность данных и вычислений ===

=== Возможные способы и особенности параллельной реализации алгоритма ===

=== Масштабируемость алгоритма и его реализации ===

=== Динамические характеристики и эффективность реализации алгоритма ===

=== Выводы для классов архитектур ===

=== Существующие реализации алгоритма ===

Существует несколько последовательных реализаций алгоритма. С одной из них можно ознакомиться по ссылке <ref name="tra">http://www.codeforge.com/article/192925</ref>.

Возможна реализация алгоритма CHAMELEON с использованием графовых библиотек, как, например METIS <ref name="tru">http://glaros.dtc.umn.edu/gkhome/metis/metis/overview</ref> , hMETIS <ref name="tri">http://glaros.dtc.umn.edu/gkhome/metis/hmetis/overview</ref> и RANN <ref name="tro">https://cran.r-project.org/web/packages/RANN/index.html</ref>.

Параллельных реализаций алгоритма CHAMELEON найдено не было. Однако существует исследование, связанное с реализацией CHAMELEON посредством технологии OpenMP, с которым можно ознакомиться здесь <ref name="tr">http://research.ijcaonline.org/volume79/number8/pxc3891600.pdf</ref>.

== Литература ==

<references \>

Участник:Артем Таран/Графо-ориентированный алгоритм кластеризации CHAMELEON

2016-11-01T11:48:36Z

Algoman: Откат правок Algoman (обсуждение) к версии Артем Таран

{{Assignment}}
{{algorithm
| name = Графо-ориентированный алгоритм кластеризации CHAMELEON
| serial_complexity = <math>O(n^2+nm+m^2log(m))</math>
| pf_height = <math>O(n + log(n) + mlog(m) + m^2log(m))</math>
| pf_width = <math>O(n)</math>
| input_data = <math>\frac{n (n - 1)}{2}</math>
| output_data = <math>n</math>
}}

Статью подготовили: [[Участник:Артем_Таран|Артём Таран Иванович]] (разделы 1.1 - 1.10, 2.7), [[Участник:ShimchikN|Шимчик Никита Владимирович]] (разделы 1.1 - 1.10, 2.7).
== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===

Кластеризация — многомерная статистическая процедура, выполняющая сбор данных, содержащих информацию о выборке объектов, и затем упорядочивающая объекты в сравнительно однородные группы (кластеры) с минимизацией межкластерного сходства и максимизацией внутрикластерного сходства.

Графо-ориентированный алгоритм кластеризации CHAMELEON<ref name="rt">http://www-users.cs.umn.edu/~han/dmclass/chameleon.pdf</ref> - алгоритм, который измеряет сходство двух кластеров на основе
динамической модели. В процессе кластеризации два кластера объединяются, только если показатели взаимосвязанности и близости между двумя кластерами являются высокими по отношению к показателям внутренней взаимосвязанности кластеров и близости элементов внутри этих кластеров. Процесс слияния с использованием динамической модели, использующийся в данном алгоритме облегчает открытие
природных и однородных кластеров. Методология динамического моделирования кластеров, использующаяся в CHAMELEON,
применима ко всем типам данных, для которых может быть построена матрица подобия.

Алгоритм кластеризации CHAMELEON включает в себя три этапа:

1) Построение графа, путём добавления рёбер по принципу k ближайших соседей.

2) Выделение множества сравнительно малых связных подграфов.

3) Формирование набора кластеров, на основе множества подграфов, полученных на предыдущем этапе.

[[Файл:Графы k ближайших соседей.jpg|1000px|thumb|center|Графы k ближайших соседей: 1) объекты в пространстве, 2) граф по принципу 1-го ближайшего соседа, 3) граф по принципу 2-го ближайшего соседа, 4) граф по принципу 3-х ближайших соседей<ref name="rt">http://www-users.cs.umn.edu/~han/dmclass/chameleon.pdf</ref>]]

=== Математическое описание алгоритма ===
==== Данные ====
* '''Исходные данные''': множество из <math>n</math> точек <math>V = \{v_{i}\}</math> в метрическом пространстве, которое может быть задано в виде треугольной матрицы расстояний <math>A</math> размера <math>n\times n</math>.

* '''Промежуточный результат после первого этапа''': граф <math>G = (V, E)</math>, полученный путём соединения каждой точки с её <math>k</math> ближайшими соседями.

* '''Промежуточный результат после второго этапа''': разбиение множества <math>V</math> на набор <math>K = \{K_{i}\}</math> попарно непересекающихся связных подмножеств, из которого образуется взвешенный граф <math>G_{2} = (K, E_{2})</math>.

* '''Промежуточный результат после третьего этапа''': итоговое разбиение множества вершин графа <math>G_{2}</math> на набор кластеров <math>C = \{C_{i}\}</math>.

* '''Вычисляемые данные''': n-мерный вектор <math>v</math> (элементы <math>v_{i}</math>), показывающий отображение исходного множества точек на набор кластеров <math>C</math>.

==== Определения ====

* ''Абсолютная взаимная связность между парой кластеров <math>C_{i}</math> и <math>C_{j}</math>'' определяется как сумма весов ребер, соединяющих вершины, принадлежащие <math>C_{i}</math> с вершинами из <math>C_{j}</math>. Эти ребра, фактически, входят в разделитель ребер графа, состоящего из кластеров <math>C_{i}</math> и <math>C_{j}</math>, и разбивающим его на подграфы <math>C_{i}</math> и <math>C_{j}</math>. Обозначается эта величина как
<math>EC_{(C_{i},C_{j})}</math>. Внутреннюю связность <math>EC_{C_{i}}</math> кластера <math>C_{i}</math> можно вычислить как сумму ребер, входящих в разделитель ребер, разбивающий <math>C_{i}</math> на два совершенно равных подграфа.

* ''Относительная взаимная <math>RI_{(C_{i},C_{j})}</math> связность пары кластеров <math>C_{i}</math> и <math>C_{j}</math>'' определяется формулой:

<math>RI_{(C_{i},C_{j})} = \frac{2*|EC_{(C_{i},C_{j})}|}{|EC_{C_{i}}|+|EC_{C_{j}}|}</math>

Учитывая значения относительной взаимной связности, можно добиться получения кластеров разного размера, формы и плотности, то есть общего внутреннего сходства.

* ''Абсолютное взаимное сходство между парой кластеров <math>C_{i}</math> и <math>C_{j}</math>'' подсчитывается как среднее сходство между соединенными вершинами, принадлежащими <math>C_{i}</math> и <math>C_{j}</math> соответственно. Эти соединения обусловлены предыдущим разбиением общего графа, полученного на матрице сходства.

* ''Относительное взаимное сходство <math>RC_{(C_{i},C_{j})}</math> между парой кластеров <math>C_{i}</math> и <math>C_{j}</math>'' определяется как абсолютное сходство между этой парой кластеров, нормализованное с учетом их внутреннего сходства и вычисляется по формуле:

<math> RC_{(C_{i},C_{j})}= \frac{S_{EC_{(C_{i},C_{j})}}}{\frac{|C_{i}|}{|C_{i}+C_{j}|}*S_{EC_{(C_{i})}}+\frac{|C_{i}|}{|C_{i}+C_{j}|}*S_{EC_{(C_{j})}}}</math>,

где <math>S_{EC_{(C_{i})}}</math> и <math>S_{EC_{(C_{i})}}</math> - средние веса ребер (значения сходства), принадлежащих разделителю ребер кластеров <math>C_{i}</math> и <math>C_{j}</math> соответственно,
и <math>S_{EC_{(C_{i},C_{j})}}</math> - средний вес ребер, соединяющих вершины <math>C_{i}</math> с вершинами <math>C_{j}</math>, причем ребра принадлежат разделителю ребер <math>EC_{(C_{i})}</math>, определенному ранее.

Далее, алгоритм применяет агломеративную иерархическую кластеризацию с использованием вышеозначенных показателей. Причем существует две стратегии их учета. Первая подразумевает наличие некоторых пороговых значений <math>T_{RI}</math> и <math>T_{RC}</math>. В соответствии с этой стратегией, алгоритм для каждого кластера <math>C_{i}</math> проверяет, отвечают ли смежные (наиболее близкие) ему кластеры условиям:

*<math>RI_{(C_{i},C_{j})} \geqslant T_{RI}</math>

*<math>RC_{(C_{i},C_{j})} \geqslant T_{RC}</math>

Если более одного смежного кластера отвечает этим условиям, то алгоритм выбирает для объединения наиболее связный кластер (граф), то есть такой кластер <math>C_{j}</math>, с которым у кластера <math>C_{i}</math> получается наибольшая абсолютная взаимная связность. По завершению прохода по всем кластерам, созданные таким образом пары объединяются. Параметры <math>T_{RI}</math> и <math>T_{RC}</math> могут использоваться для изменения характеристик получаемых кластеров.

Вторая стратегия заключается в использовании специальной функции, объединяющей понятия относительной взаимной связности и относительного взаимного сходства. На каждом шаге выбираются те кластеры для объединения, которые максимизируют эту функцию:

<math>RI_{(C_{i},C_{j})}*RC_{(C_{i},C_{j})}^\alpha</math>,

где <math>\alpha</math> выбирается пользователем. Если <math>\alpha > 1 </math>, то алгоритм придает большее значение относительному взаимному сходству, а если <math>\alpha < 1 </math>, то большее значение имеет относительная взаимная связность. Разумеется, данный подход позволяет получить полную дендрограмму кластерного анализа<ref name="rty">http://studopedia.ru/7_41934_algoritm-dinamicheskoy-ierarhicheskoy-klasterizatsii-CHAMELEON.html</ref>.

=== Вычислительное ядро алгоритма ===

На первом этапе работы алгоритма вычислительным ядром можно считать процесс нахождения k ближайших соседей для каждой отдельной вершины.

На втором этапе работы алгоритма вычислительным ядром является поиск разбиения графа на два подграфа с минимизацией разделителя рёбер графа.

На третьем этапе работы алгоритма вычислительным ядром является расчёт <math>EC_{(C_{i},C_{j})}</math>, <math>RC_{(C_{i},C_{j})}</math> и <math>RI_{(C_{i},C_{j})}</math> для пары смежных кластеров, а также их слияние.

=== Макроструктура алгоритма ===

Алгоритм CHAMELEON выполняется в 3 этапа, последовательных относительно друг друга. Каждый этап соответствует отдельному алгоритму.

* Макрооперацией на первом этапе является процедура выделения k ближайших соседей.

* Макрооперацией на втором этапе является процедура разбиения наибольшего подграфа на каждой итерации.

* Макрооперациями на третьем этапе являются процедуры вычисления метрики для принятия решения об объединении кластеров и объединение кластеров на каждой итерации.

=== Схема реализации последовательного алгоритма ===

* Первый этап (псевдокод):
integer n; // Количество точек.
integer k; // Параметр k
integer A[n][n]; // Верхняя треугольная матрица расстояний между точками.

integer E[n][n]; // Верхняя треугольная матрица рёбер графа G - изначально инициализирована нулями.
foreach (integer i in (1,n-1) ) {
integer Neighbors[k]; // матрица, используемая хранения ближайших соседей
integer countN = 0;

foreach (integer j in (i+1, n) ) {
// Заполняем матрицу Neighbors, добавляя новые элементы и увеличивая счётчик countN.
// Когда countN станет равен k, новые элементы будут вставляться на место старых, либо отбрасываться.
}

foreach (integer j in (0, countN) ) {
E[min(i,j), max(i,j)] = 1;
}
}
return E;

* Второй этап:
[[File:Диаграмма_шаг_2.png]]

* Третий этап:
[[File:Chameleon_stage_3.png|611px]]

=== Последовательная сложность алгоритма ===
1) Построение графа на основе метода k ближайших соседей в худшем случае требует <math>O(n^2)</math> операций;

2) Для выделения множества сравнительно малых связных подграфов требуется <math>nm</math> операций;

3) Формирование набора кластеров, на основе множества подграфов, полученных на предыдущем этапе, требует <math>m^2log(m)</math> операций.

Итого, получаем последовательную сложность <math>O(n^2+nm+m^2log(m))</math>.

=== Информационный граф ===

[[File:Chameleon_inforgraph.png|811px]]

=== Ресурс параллелизма алгоритма ===

Первый этап работы алгоритма можно распределить между <math>n</math> процессами: в этом случае каждому процессу назначается своя точка и происходит поиск <math>k</math> ближайших соседей. Таким образом, его параллельная сложность составляет <math>O(n)</math>.

На втором этапе количество задействованных процессов может варьироваться в зависимости от входных данных. В худшем случае число итераций можно оценить как <math>O(log(n))</math>.

На третьем этапе можно распараллелить процесс расчёта метрик сходства между кластерами, однако итоговое слияние всё равно должно выполняться последовательно.
Поскольку процесс сравнения кластеров возможно распараллелить, сложность 3-го этапа составляет <math>mlog(m) + m^2log(m)</math>.

Таким образом, суммарная параллельная сложность оказывается равна <math>O(n + log(n) + mlog(m) + m^2log(m))</math>.

=== Входные и выходные данные алгоритма ===

* Входные данные:

1) Треугольная матрица <math>A</math> размера <math>n\times n</math> (где n — количество объектов), в которой элементу <math>a_{ij}</math> соответствует расстояние между i-м и j-м объектами.

2) Количество ближайших соседей <math>k</math> для вершин (рекомендуемое значение <math>k</math> от 5 до 20 в зависимости от количества анализируемых объектов).

3) Наименьшее число вершин, которое может содержать наибольший подграф на 2-м этапе <math>l</math>. Величина этого параметра варьируется от 1 до 5 % от общего числа объектов.

* Объём входных данных: <math>\frac{n (n - 1)}{2}</math>

* Выходные данные: n-мерный вектор <math>v</math>, в котором элементу <math>v_{i}</math> соответствует номер кластера, присвоенный i-му объекту

* Объём выходных данных: <math>n</math>

=== Свойства алгоритма ===

Первый этап алгоритма обладает хорошим ресурсом параллелизма: параллельная сложность его выполнения составляет <math>O(n)</math>, что намного лучше последовательной оценки <math>O(n^2)</math>.

У второго и третьего этапов алгоритма сложно полностью оценить ресурсы параллелизма. Но оба этапа возможно частично распараллелить.

'''Вычислительную мощность''' для разных этапов алгоритма можно оценить как:

1 этап: <math>O(1)</math>

2 этап: <math>O(\frac{nm}{n^2+m^2})</math>

3 этап: <math>O(\frac{m^2log(m)}{m^2+n})</math>

Детерминированность: Важной особенностью данного алгоритма является его недетерминированность. Несмотря на то, что 1-й этап детерминирован, алгоритм в целом является недетерминированным, так как на 2-ом этапе могут быть найдены различные разбиения на подграфы, а это повлияет и на итоговый результат работы алгоритма.

== Программная реализация алгоритма ==

=== Особенности реализации последовательного алгоритма ===

=== Локальность данных и вычислений ===

=== Возможные способы и особенности параллельной реализации алгоритма ===

=== Масштабируемость алгоритма и его реализации ===

=== Динамические характеристики и эффективность реализации алгоритма ===

=== Выводы для классов архитектур ===

=== Существующие реализации алгоритма ===

Существует несколько последовательных реализаций алгоритма. С одной из них можно ознакомиться по ссылке <ref name="tra">http://www.codeforge.com/article/192925</ref>.

Возможна реализация алгоритма CHAMELEON с использованием графовых библиотек, как, например METIS <ref name="tru">http://glaros.dtc.umn.edu/gkhome/metis/metis/overview</ref> , hMETIS <ref name="tri">http://glaros.dtc.umn.edu/gkhome/metis/hmetis/overview</ref> и RANN <ref name="tro">https://cran.r-project.org/web/packages/RANN/index.html</ref>.

Параллельных реализаций алгоритма CHAMELEON найдено не было. Однако существует исследование, связанное с реализацией CHAMELEON посредством технологии OpenMP, с которым можно ознакомиться здесь <ref name="tr">http://research.ijcaonline.org/volume79/number8/pxc3891600.pdf</ref>.

== Литература ==

<references \>

Обсуждение участника:Артем Таран

2016-11-01T11:48:25Z

Algoman: Отмена правки 15092, сделанной участником Algoman (обс.)

== Замечания к [[Участник:Артем_Таран/Графо-ориентированный_алгоритм_кластеризации_CHAMELEON]] ==

1) отсутствует оценка вычислительной мощности алгоритма в п 1.10

Обсуждение участника:Артем Таран

2016-11-01T11:48:19Z

Algoman: Отмена правки 15093, сделанной участником Algoman (обс.)

== Замечания к [[Участник:Артем_Таран/Графо-ориентированный_алгоритм_кластеризации_CHAMELEON]] ==

1) отсутствует оценка вычислительной мощности алгоритма в п 1.10

== Замечения от 31.10

отсутсвует ссылка на источник картинки
"- В конце статьи должен быть приведен список всех источников, откуда бралась информация по алгоритму. Если вы используется готовый рисунок, то сслыку на источник нужно разместить либо в подписи к рисунку, либо в тексте, где стоит ссылка на рисунок."

Участник:Александр Куваев/Алгоритм кластеризации, основанный на максимизации ожидания

2016-11-01T10:45:25Z

Algoman:

{{Assignment|Algoman}}

Авторы описания:
* Куваев А.С., группа 620 (математическая постановка задачи, схема реализации алгоритма, оценка сложности, описание ресурса параллелизма)
* Щенявская Е.В., группа 616 (описание алгоритма, визуализация информационного графа и примера работы алгоритма, описание свойств алгоритма)

== Свойства и структура алгоритмов ==

=== Общее описание алгоритма ===
Задача кластеризации заключается в разбиении входного множества объектов на непересекающиеся подмножества, называемые кластерами, так, чтобы каждый кластер состоял из схожих объектов, а объекты разных кластеров существенно отличались друг от друга<ref name=vorontsov>Воронцов К.В., Математические методы обучения по прецедентам.</ref>.

Решение этой задачи принципиально неоднозначно по следующим причинам<ref name=vorontsov/>:
# результат кластеризации зависит от способа задания меры сходства объектов выборки
# не существует однозначно наилучшего критерия качества кластеризации
# число кластеров, как правило, неизвестно заранее и задается из некоторых априорных соображений (хотя существуют алгоритмы, способные определять число кластеров автоматически)

По описанной выше причине существует большое число алгоритмов кластеризации, приводящих к различным разбиениям исходного множества объектов. На этой странице представлено описание одного из таких методов — EM-алгоритма. EM-алгоритм опирается на предположение о вероятностной природе данных: элементы выборки получены случайно и независимо из смеси распределений с фиксированным числом компонент <math>k</math>. Таким образом, плотность распределения на множестве объектов имеет следующий вид:

:<math>p(x)=\sum_{j=1}^{k}w_{j}p_{j}(x), \ \sum_{j=1}^{k}w_{j}=1, \ w_{j} \ge 0 </math>, где <math>p_{j}</math> - плотность распределения <math>j</math>-й компоненты смеси (кластера).

Везде в дальнейшем будем предполагать, что <math>p_{j}</math> имеют вид многомерных нормальных плотностей с произвольной матрицей ковариации: смеси нормальных распределений позволяют аппроксимировать произвольные непрерывные функции плотности с наперед заданной точностью<ref name=korolev>Королёв В.Ю., ЕМ-алгоритм, его модификации и их применение к задаче разделения смесей вероятностных распределений. Теоретический обзор. - М.: ИПИРАН, 2007.</ref>. Результатом работы EM-алгоритма являются оценки априорных вероятностей компонент смеси <math>w_{j}</math>, а также оценки векторов математических ожиданий и матриц ковариаций для каждой компоненты. Зная параметры распределения смеси, каждому объекту будет сопоставляться тот кластер, вероятность принадлежности к которому будет максимальной.

EM-алгоритм позволяет значительно упростить задачу максимизации правдоподобия выборки путем искусственного введения вспомогательной матрицы скрытых переменных <math>G</math>. Алгоритм заключается в последовательном повторении шагов E(expectation) и M(maximization):
* На шаге E на основе текущего приближения параметров смеси по формуле Байеса вычисляются ожидаемые значения скрытых переменных <math>g_{ij}</math> — апостериорные вероятности того, что <math>i</math>-й объект принадлежит кластеру <math>j</math>.
* На шаге M решается задача максимизации правдоподобия для нахождения следующего приближения параметров смеси на основе текущего приближения и матрицы скрытых переменных, при этом решение этой задачи выписывается в явном виде.

[[File:EM iterations.png|thumb|center|800px|Рисунок 1. Визуализация компонент смеси после некоторых итераций алгоритма в двумерном пространстве признаков. Для каждой компоненты эллипсами выделены доверительные области с уровнями доверия 0.9, 0.95 и 0.99.]]

=== Математическое описание алгоритма ===
Пусть заданы <math>l</math> объектов <math>x_{1},\dotsc,x_{l}</math>, каждый из которых описывается <math>n</math> числовыми признаками. Таким образом, определена матрица объектов-признаков <math>X \in \R^{l \times n}.</math> Предполагается, что объекты выбраны случайно и независимо из смеси <math>n</math>-мерных нормальных распределений с фиксированным числом компонент <math>k</math>. Плотность распределения на множестве объектов имеет вид:

:<math>p(x)=\sum_{j=1}^{k}w_{j}p_{j}(x), \ \sum_{j=1}^{k}w_{j}=1, \ w_{j} \ge 0 </math>, где <math>p_{j}</math> - плотность распределения <math>j</math>-й компоненты смеси.

Каждая компонента смеси описывается <math>n</math>-мерным вектором математических ожиданий <math>\mu_{j}</math> и матрицей ковариаций <math>\Sigma_{j}</math> порядка <math>n</math>, <math>j = 1,\dotsc,k</math>.

'''Входные данные:''' матрица объектов-признаков <math>X</math>, число кластеров <math>k</math>, максимальное число итераций <math>imax</math>, минимальная величина изменения логарифма правдоподобия <math>\varepsilon</math>.

'''Выходные данные:''' набор оценок весов, математических ожиданий и ковариационных матриц компонент смеси <math>\theta = (w_{1},...,w_{k}; \; \mu_{1},...,\mu_{k}; \; \Sigma_{1},...,\Sigma_{k})</math>, максимизирующий правдоподобие выборки.

'''Структура алгоритма:'''
* '''Инициализация параметров:''' существует большое число вариантов инициализации параметров распределения. Один из возможных подходов — задание векторов математических ожиданий компонент случайными элементами выборки, задание матриц ковариаций единичными матрицами и задание весов компонент равными <math>\frac{1}{k}.</math>
* '''Последовательное выполнение шагов E и M''' до тех пор, пока правдоподобие выборки не стабилизируется или не будет достигнуто максимальное число итераций:
** '''Шаг E:''' вычисление значений скрытых переменных по формуле Байеса:
*:<math>g_{ij} = \frac{w_{j} p_{j}(x_{i})}{\sum_{s=1}^{k} w_{s} p_{s}(x_{i})}</math> , где <math>p_{j}(x_{i}) = \frac{1}{(2\pi)^{n/2}\sqrt{|\Sigma_{j}|}} \exp \biggl( -\frac{1}{2}(x_{i} - \mu_{j})^{T} \Sigma_{j}^{-1} (x_{i} - \mu_{j}) \biggr), \ i = 1,\dotsc,l; \ j = 1,\dotsc,k </math>
** '''Шаг M:''' перерасчет параметров смеси на основе текущего приближения и матрицы скрытых переменных:
*:<math>w_{j} = \frac{1}{l} \sum_{i=1}^{l} g_{ij}, \ j = 1,\dotsc,k;</math>
*:<math>\mu_{j} = \frac{1}{l w_{j}} \sum_{i=1}^{l} g_{ij} x_{i}, \ j = 1,\dotsc,k;</math>
*:<math>\Sigma_{j} = \frac{1}{l w_{j}} \sum_{i=1}^{l} g_{ij}(x_{i} - \mu_{j})(x_{i} - \mu_{j})^T, \ j = 1,\dotsc,k.</math>

=== Вычислительное ядро алгоритма ===
Вычислительное ядро EM-алгоритма — процедура последовательного выполнения шагов E и M:
* На шаге E на основе текущего приближения параметров смеси вычисляются ожидаемые значения скрытых переменных
* На шаге M вычисляется следующее приближение параметров смеси на основе текущего приближения и матрицы скрытых переменных
Наиболее трудоемкой операцией с вычислительной точки зрения является шаг E, в ходе которого производится обращение ковариационных матриц, вычисление их определителей, а также многократное перемножение векторов и матриц при вычислении скрытых переменных.

=== Макроструктура алгоритма ===
Алгоритм состоит из двух итерационно проводимых макроопераций: E-шага и M-шага.

В ходе E-шага используется:
* Обращение ковариационной матрицы и вычисление ее определителя
* Умножение вектор-строки на матрицу и вектор-строки на вектор-столбец
В ходе M-шага используется:
* Умножение вектор-столбца на вектор-строку
* Взвешенное суммирование векторов и матриц

=== Схема реализации последовательного алгоритма ===
# Для всех <math>j = 1,\dotsc,k</math>:
#: Инициализировать <math>w_{j}, \ \mu_{j}, \ \Sigma_{j}</math>
# Для всех <math>iter = 1,\dotsc,imax</math>:
## Шаг E:
##: Для всех <math>j = 1,\dotsc,k</math>:
##:: Вычислить <math>|\Sigma_{j}|, \ \Sigma_{j}^{-1}</math>
##: Для всех <math>i = 1,\dotsc,l</math>:
##:: <math>sum = 0</math>
##:: Для всех <math>j = 1,\dotsc,k</math>:
##::: Вычислить <math>p_{j}(x_{i}) = \frac{1}{(2\pi)^{n/2}\sqrt{|\Sigma_{j}|}} \exp \biggl( -\frac{1}{2}(x_{i} - \mu_{j})^{T} \Sigma_{j}^{-1} (x_{i} - \mu_{j}) \biggr)</math>
##::: <math>sum = sum + w_{j}p_{j}(x_{i})</math>
##:: Для всех <math>j = 1,\dotsc,k</math>:
##::: Вычислить <math>g_{ij} = \frac{w_{j} p_{j}(x_{i})}{sum}</math>
## Шаг M:
##: Для всех <math>j = 1,\dotsc,k</math>:
##:: Вычислить <math>w_{j} = \frac{1}{l} \sum_{i=1}^{l} g_{ij}</math>
##:: Вычислить <math>\mu_{j} = \frac{1}{l w_{j}} \sum_{i=1}^{l} g_{ij} x_{i}</math>
##:: Вычислить <math>\Sigma_{j} = \frac{1}{l w_{j}} \sum_{i=1}^{l} g_{ij}(x_{i} - \mu_{j})(x_{i} - \mu_{j})^T</math>
## Вычислить изменения логарифма правдоподобия <math>\Delta</math>
## Если <math>\Delta < \varepsilon</math>, то досрочно выйти из цикла
# Вернуть <math>w_{j}, \mu_{j}, \Sigma_{j}, \ j = 1,\dotsc,k.</math>

=== Последовательная сложность алгоритма ===
Рассмотрим мультипликативную сложность одной итерации алгоритма:
* '''E-шаг:'''
** Сложность обращения матрицы ковариаций и вычисления ее определителя — <math>O(n^{3})</math> (для простоты будем рассматривать метод Гаусса)
** Сложность вычисления расстояния Махаланобиса (показателя экспоненты) при вычислении значения каждой скрытой переменной — <math>O(n^{2})</math>
** Общая сложность E-шага — <math>O(k * n^{3} + k * l * n^{2})</math>
* '''M-шаг:'''
** Сложность пересчета веса кластера — <math>O(l)</math>
** Сложность пересчета центра кластера — <math>O(l * n)</math>
** Сложность пересчета матрицы ковариаций кластера — <math>O(l * n)</math>
** Общая сложность M-шага — <math>O(k * l * n)</math>

Таким образом, общая сложность одной итерации — <math>O(k * n^{2} * (l + n))</math>. При учете ограничения на максимальное число итераций получим оценку общей сложности алгоритма — <math>O(imax * k * n^{2} * (l + n))</math>.

Большое влияние на сложность E-шага оказывает необходимость обращать ковариационные матрицы и вычислять их определители. Помимо того, что это трудоемкая операция, ковариационные матрицы могут оказаться плохо обусловленными, что может привести к неустойчивости выборочных оценок параметров смеси. Обращения матриц можно избежать, если принять гипотезу о том, что в каждой компоненте смеси признаки некоррелированы, то есть ковариационные матрицы диагональные. В таком случае общая сложность алгоритма составит <math>O(imax * k * n * l)</math>.

=== Информационный граф ===
На рисунках 2 и 3 представлены информационные графы<ref name=voevodin>Воеводин В.В., Воеводин Вл.В. Параллельные вычисления. - СПб.: БХВ-Петербург, 2002. - 608 с.</ref> шагов E и M соответственно. Прямоугольниками обозначены входные данные (с пометкой in/out), эллипсами обозначены операции, производимые над данными согласно алгоритму.

Как видно из рисунка 2, E-шаг распадается на:
* Обращение матриц ковариаций и вычисление их определителей
* Независимый расчет скрытых переменных по каждому объекту

[[File:E-step.png|thumb|center|1100px|Рисунок 2. Граф шага E с отображением входных и выходных данных.]]

На рисунке 3 видно, что некоторые промежуточные вычисления на шаге M можно проводить независимо для каждого объекта, но после этого придется проводить агрегацию полученных результатов по кластерам.

[[File:M-step.png|thumb|center|1100px|Рисунок 3. Граф шага M с отображением входных и выходных данных.]]

=== Ресурс параллелизма алгоритма ===
Из информационных графов на рисунках 2 и 3 видно, что:
* Шаг E — наиболее ресурсоемкий этап алгоритма — эффективно распараллеливается по объектам после предварительного обращения матриц ковариаций и вычисления их определителей: при расчете скрытых переменных для фиксированного объекта информация о других объектах не используется. Также стоит отметить, что для всех объектов выполняется одна и та же последовательность действий. Таким образом, параллельная сложность E-шага — <math>O(k * n^{2})</math>.
* Менее ресурсоемкий шаг M распараллеливается хуже: промежуточные вычисления можно проводить независимо для каждого объекта, но после этого придется проводить агрегацию полученных результатов по кластерам.

=== Входные и выходные данные алгоритма ===
'''Входные данные:''' плотная матрица объектов-признаков <math>X \in \R^{l \times n}</math>, число кластеров <math>k \in \N</math>, максимальное число итераций <math>imax \in \N</math>, минимальная величина изменения логарифма правдоподобия <math>\varepsilon \in \R</math>.

'''Объём входных данных:''' <math>ln + 3</math>

'''Выходные данные:''' вещественный вектор весов <math>w \in \R^{k}</math>, <math>k</math> вещественных векторов математических ожиданий <math>\mu_{j} \in \R^{n}</math> и <math>k</math> вещественных ковариационных матриц <math>\Sigma_{j} \in \R^{n \times n}</math>.

'''Объём выходных данных:''' <math>k(n^{2}+n+1)</math>

=== Свойства алгоритма ===
Вычислительная мощность EM-алгоритма в предположении о том, что <math>l \gg n</math> (это условие выполняется в подавляющем большинстве прикладных задач), оценивается величиной <math>O(imax * k * n)</math>.

Достоинства EM-алгоритма:
* Мощная математическая основа
* Слабая чувствительность к выбросам
* Быстрая сходимость при удачной инициализации параметров
* Линейный рост сложности при увеличении количества объектов

Недостатки EM-алгоритма:
* В классическом варианте не может самостоятельно определить количество компонент смеси
* Трудоемкий и неустойчивый процесс обращения матриц ковариаций в случае несферических компонент смеси
* Не является детерминированным: в начале работы происходит инициализация начальных параметров случайным образом
* Не является устойчивым: результат работы сильно зависит от инициализации параметров. При неудачной инициализации может обладать низкой скоростью сходимости, может сойтись к локальному экстремуму или не сойтись вовсе

== Программная реализация алгоритма ==

=== Особенности реализации последовательного алгоритма ===

=== Локальность данных и вычислений ===

=== Возможные способы и особенности параллельной реализации алгоритма ===

=== Масштабируемость алгоритма и его реализации ===

=== Динамические характеристики и эффективность реализации алгоритма ===

=== Выводы для классов архитектур ===

=== Существующие реализации алгоритма ===
# [http://scikit-learn.org/stable/modules/generated/sklearn.mixture.GaussianMixture.html#sklearn.mixture.GaussianMixture scikit-learn(Python)]
# [http://docs.opencv.org/2.4/modules/ml/doc/expectation_maximization.html OpenCV(C++/Python)]
# [http://www.mlpack.org/docs/mlpack-git/doxygen.php?doc=classmlpack_1_1gmm_1_1GMM.html MLPack(C++)]
# [http://arma.sourceforge.net/docs.html#gmm_diag Armadillo(C++)]
# [https://www.mathworks.com/help/stats/fitgmdist.html Matlab]

== Литература ==

Участник:Мария Готман/Алгоритм кластеризации, основанный на максимизации ожидания

2016-11-01T10:44:08Z

Algoman:

{{Assignment|Algoman}}

Авторы описания: [[Участник:Мария_Готман|Готман М.Л.]], [[Участник:Julia_lukashkina|Лукашкина Ю.Н.]]

= ЧАСТЬ. Свойства и структура алгоритмов =
== Общее описание алгоритма ==
Задача кластеризации — это задача разбиения заданной входной выборки объектов на непересекающиеся подмножества, называемые кластерами, так, чтобы каждый кластер состоял из схожих объектов, а объекты разных кластеров существенно отличались.

Для решения этой задачи можно использовать, например, метод максимизации ожидания, также известный как EM-алгоритм (англ. expectation-maximization) <ref>Воронцов К.В.; Математические методы обучения по прецедентам (теория обучения машин)</ref>. В таком случае делается предположение, что входные данные — смесь многомерных нормальных распределений, соотвественно отдельный кластер — это одна компонента смеси. Предполагается, что количество кластеров является входным параметром алгоритма (существуют модификации EM-алгоритма, которые автоматически находят число кластеров, но они не рассматриваются в данной статье). Результат работы EM-алгоритма — веса кластеров и найденные параметры нормальных распределений для каждого кластера: вектора математических ожиданий и матрицы ковариации.

Алгоритм EM кластеризации основан на итеративном выполнении двух последовательных шагов: E-шага и M-шага. На E-шаге вычисляеются вспомогательные (скрытые) переменные, которые характеризуют апостериорную вероятность того, что определенный обучающий объект получен из фиксированной компоненты смеси. На M-шаге с помощью вычесленных скрытых переменных производится обновление параметров смеси: по определённым формулам пересчитываются веса кластеров, их математические ожидания и матрицы ковариаций.

Стоит отметить, что на работу EM-алгоритма значительно влияет начальное приближение его параметров. При неудачной инициализации алгоритм может не сойтись или сойтись в локальный экстремум.

В данной статье рассматривается частный случай EM-алгоритма, который работает с двумерными входными данными.

[[Файл:Em clusters 4.png|400px|thumb|center|Пример работы EM-алгоритма для 5ти кластеров.]]

== Математическое описание алгоритма ==
Рассматривается смесь нормальных распределений <math>p(x)=\sum_{j=1}^kw_jp_j(x), \sum_{j=1}^kw_j =1, w_j \ge 0</math>.

Алгоритм кластеризации, основанный на максимизации правдоподобия, итеративно выполняет два шага: E-шаг и M-шаг.
Идея алгоритма заключается в введении матрицы скрытых переменных <math>G</math>, где <math>g_{ij} \equiv P(\theta_j |x_i)</math> обозначает вероятность принадлежности <math>i</math>-го объекта <math>j</math>-му кластеру.

На Е-шаге вычисляется ожидаемое значение скрытых переменных, на М-шаге выполняется максимизация логарифма полного правдоподобия, результатом которой являются новые значения параметров модели.

На вход алгоритму подается матрица объектов-признаков <math>X \in \R^{m \times d}</math> и <math>k</math> — количество кластеров.

На выходе получаем набор параметров модели для каждого кластера <math>\Theta = (w_1,...,w_k;\;\mu_1,...,\mu_k;\;\Sigma_1,...,\Sigma_k)</math>, где <math>w_j</math> — вес <math>j</math>-го кластера в смеси нормальных распределений, <math>\mu_j</math> — математическое ожидание <math>j</math>-ой компоненты смеси, <math>\Sigma_j</math> — матрица ковариации <math>j</math>-ой компоненты смеси.

E-шаг:

<math>g_{ij} = \frac{w_jN(x_i;\mu_j, \Sigma_j)}{\sum_{s=1}^k w_sN(x_i;\mu_s, \Sigma_s)}</math>

M-шаг:

<math>Q(\Theta) = \ln\prod_{i=1}^mp(x_i) = \sum_{i=1}^m\ln\sum_{j=1}^kw_jp_j(x_i) \rightarrow \max_{\Theta}</math>, при условии <math>\sum_{j=1}^kw_j=1</math>, где

<math>p_j(x_i) = N(x_i;\mu_j, \Sigma_j) = \frac1{(2\pi)^{d/2}\sqrt{|\Sigma_j|}} \exp \biggl(-\frac{1}{2}(x_i - \mu_j) \Sigma_j^{-1} (x_i - \mu_j)^T\biggr) </math>

Решением оптимизационной задачи являются формулы для пересчета параметров:

<math>w_j = \frac1m\sum_{i=1}^m g_{ij}</math>,

<math>\mu_j = \frac1{mw_j}\sum_{i=1}^m g_{ij}x_i</math>,

<math>\Sigma_j = \frac1{mw_j}\sum_{i=1}^m g_{ij}(x_i - \mu_j)(x_i - \mu_j)^T,\; j = 1, \dots, k</math>

== Вычислительное ядро алгоритма ==
Вычислительное ядро алгоритма представляет собой итерационное вычисление всех параметров модели, независимое по <math>m</math> объектам выборки <math>X</math>.
На каждой итерации алгоритма на Е-шаге пересчитывается значение скрытых переменных, на M-шаге пересчет параметров модели с учетом скрытых переменных.

== Макроструктура алгоритма ==
Как записано в [[#Вычислительное ядро алгоритма|описании ядра алгоритма]], основную часть метода составляют вычисления элементов матрицы G на E шаге, и пересчет параметров <math>\Theta</math> на M-шаге.

== Схема реализации последовательного алгоритма ==
# Инициализация параметров
# for iter = 1 : max_iterations
# [E-шаг]
## вычисление <math>\Sigma_j^{-1}</math> и <math>\frac1{(2\pi)^{d/2}\sqrt{|\Sigma_j|}}, j = 1 : k</math>
## вычисление <math>g_{ij},\;i = 1 : m, \; j = 1 : k</math>
## вычисление <math>LL_i</math> (логарифм правдоподобия), <math>\;i = 1 : m</math>
# [M-шаг]
## вычисление <math>\tilde w_j = \sum_{i=1}^m g_{ij}, \; j = 1 : m</math>
## вычисление <math>\tilde \mu_j = \sum_{i=1}^m g_{ij}x_i,\; j = 1 : k</math>
## вычисление <math>\tilde \Sigma_j = \sum_{i=1}^m g_{ij}(x_i - \mu_j)^T(x_i - \mu_j),\; j = 1 : k</math>
## нормировка <math>w_j = \frac{\tilde w_j}{m}</math>, <math>\mu_j = \frac{\tilde \mu_j}{w_j}, \tilde \Sigma_j = \frac{\tilde \Sigma_j}{w_j}, \;j = 1 : k</math>
# вычисление изменения логарифма правдоподобия<math>\Delta LL</math>
# if (<math>\Delta LL < \varepsilon</math>) then break;
# end for

== Последовательная сложность алгоритма ==
E-шаг:
# вычисление обратной матрицы <math>\Sigma_j^{-1}, j = 1 : k</math> при фиксированном <math>j</math> для двумерного случая по явным формулам имеет сложность <math>O(d^2)</math>, для всех кластеров — <math>O(d^2k)</math>
# вычисление <math>g_{ij}, i = 1 : m, j = 1 : k</math> при фиксированных <math>i, j</math> имеет сложность <math>O(d)</math>, сложность вычисления матрицы G — <math>O(dmk)</math>
# вычисление <math>LL_i, i = 1 : m</math> при фиксированном <math>i</math> имеет сложность <math>O(k)</math>, для всех объектов имеет сложность <math>O(mk)</math>,
M-шаг:
# вычисление <math>w_j, j = 1 : k</math> при фиксированном <math>j</math> имеет сложность <math>O(m)</math>, для весов всех кластеров — <math>O(mk)</math>
# вычисление <math>\mu_j, j = 1 : k</math> при фиксированном <math>j</math> имеет сложность <math>O(dm)</math>, для всех кластеров — <math>O(dmk)</math>
# вычисление <math>\Sigma_j, j = 1 : k</math> при фиксированном <math>j</math> имеет сложность <math>O(d^2m)</math>, для всех кластеров — <math>O(d^2mk)</math>
# нормировка <math>w</math>, <math>\mu_j = \frac{\mu_j}{w_j}, \Sigma_j = \frac{\Sigma_j}{w_j}, j = 1 : k</math> имеет сложность <math>O(k)</math>, <math>O(dk)</math>, <math>O(d^2k)</math>
# вычисление изменения логарифма правдоподобия<math>\Delta LL</math> имеет сложность <math>O(1)</math>

Сложность алгоритма на одной итерации:

<math>O(k(d^2+dm+m+m+dm+d^2m+1+d+d^2)) = O(d^2mk)</math>, так как мы рассматриваем задачу для двумерного случая, то есть <math>d=2</math>, множитель <math>d^2</math> можно отнести в константу, итоговая сложность вычисления на одной итерации <math>O(mk)</math>.

Для <math>n</math> итераций итоговая сложность алгоритма будет равна:

<math>O(mkn)</math>, где <math>m</math> — число объектов, <math>k</math> — число кластеров, <math>n</math> — число итераций.

== Информационный граф ==

Опишем граф алгоритма для следующих входных данных: <math>m = 3,\; k = 2,\; d = 2</math>, то есть 3 входных объекта и 2 кластера.

На рис.1 показана макроструктура EM-алгоритма. Входными данными в таком случае являются матрица <math>X \in \R^{3 \times 2}</math> и число кластеров <math>k = 2</math>.
На шаге <math>\mathbf{init}</math> происходит инициализация начальных приближений параметров модели и затем итеративное повторение <math>\mathbf{E}</math> и <math>\mathbf{M}</math> шагов алгоритма.

[[file:EM.png|thumb|center|300px|Рис.1. Граф EM-алгоритма с отображением входных и выходных данных]]

E-шаг. На рис.2 детально изображена схема E-шага.
Входные параметры <math>x_1,\; x_2,\; x_3 \in \R^{1 \times 2}</math> являются строчками входной матрицы <math>X</math>, также на вход подаются текущие приближения векторов средних значений (<math>\mu_1, \;\mu_2</math>), матриц ковариаций (<math>\Sigma_1, \Sigma_2</math>) и весов <math>w</math>.

Вершинами <math>\mathbf{eI}</math> обозначена операция нахождения обратной матрицы <math>\Sigma_j^{-1},\; j = 1,2</math>. Вершины группы <math>\mathbf{eS}</math> обозначают вычитание векторов <math>x_i - \mu_j,\; i = 1,2,3; \; j = 1, 2</math>. Салатовые узлы графа <math>\mathbf{eE}</math> обозначают вычисление ненормированного значения <math>g_{ij}, \;i = 1,2,3;\;j=1,2</math> по формулам из раздела [[#Схема реализации последовательного алгоритма|описания алгоритма]]. Далее выход вершин этой группы подаётся на вход вершинам <math>\mathbf{eN}</math>, которые обозначают нормировку, затем в <math>\mathbf{eL}</math> происходит подсчет логарифма правдоподобия. На выходе этого графа получаются скрытые переменные <math>g_{ij}</math> и логарифм правдоподобия LL.

[[file:EM_E_step.png|thumb|center|500px|Рис.2. Граф E-шага с отображением входных и выходных данных]]

M-шаг. На рисунке 3 изображена схема M-шага.
Входными параметрами являются: исходные объекты <math>x_1,\; x_2,\; x_3 \in \R^{1 \times 2}</math>, скрытые переменные <math>g_{11},\;g_{21},\;g_{31},\;\mu_1</math> для пересчета параметров первого кластера и <math>g_{12},\;g_{22},\;g_{32},\;\mu_2</math> — для второго.

Вершина <math>\mathbf{m}\boldsymbol{\mu}</math> обозначает подсчет слагаемого математического ожидания для одного объекта, затем на шаге <math>\mathbf{mS_1}</math> происходит суммирование слагаемых, и, наконец, на шаге <math>\mathbf{mN_1}</math> нормировка математического ожидания, выходом являются <math>\mu_1,\;\mu_2</math>.
Вершина <math>\mathbf{m}\boldsymbol{\Sigma}</math> обозначает подсчет слагаемого матрицы ковариации для одного объекта, затем на шаге <math>\mathbf{mS_2}</math> происходит суммирование слагаемых, и, наконец, на шаге <math>\mathbf{mN_2}</math> нормировка матрицы ковариации, выходом являются <math>\Sigma_1,\;\Sigma_2</math>.
Операция <math>\mathbf{mS_3}</math> обозначает вычисление ненормированного веса для одного шага, затем при выполнении <math>\mathbf{mN_3}</math> происходит нормировка весов, выходом являются <math>w_1,\;w_2</math>.

[[file:EM_M_step.png|thumb|center|500px|Рис.3. Граф M-шага с отображением входных и выходных данных]]

На рис.1 показана структура ЕM-алгоритма для кластеризации, на рис.2 — структура E-шага и на рис.3 — структура M-шага.

== Ресурс параллелизма алгоритма ==
Как видно из информационного графа, возможно распараллеливание как по кластерам, так и по объектам. Однако, в реальных задачах число кластеров много меньше числа объектов, поэтому распараллеливание по кластерам нецелесообразно.

В данной статье рассматривается вариант распараллеливания по объектам. Стоит отметить, что важно корректно организовать работу с параметрами модели (матрицами ковариаций, средними значениями и весами), чтобы не произошло ситуации гонки за ресурсами <ref>Воеводин В.В., Воеводин Вл.В. Параллельные вычисления. - СПб.: БХВ-Петербург, 2002. - 608 с.</ref>.

== Входные и выходные данные алгоритма ==

'''Входные данные''': плотная вещественная матрица объекты-признаки <math>X \in \R^{m \times d}</math>, количество кластеров <math>k</math>

'''Объём входных данных''': <math>m \times d + 1</math>

'''Выходные данные''': вектор весов <math>w \in \R^{k \times 1}</math>, <math>\;\;k</math> векторов <math>\mu_j \in \R^{d \times 1}</math>, <math>\;\;k</math> матриц <math>\Sigma \in \R^{d \times d}</math>

'''Объём выходных данных''': <math>k \times (d \times d + d + 1)</math>

Стоит заметить, что модель смеси распеределения полностью восстанавливается по выходным данным, и задача предсказания метки кластера для входных объектов является тривиальной.

== Свойства алгоритма ==

[[глоссарий#Вычислительная мощность|''Вычислительная мощность'']] алгоритма равна отношению числа операций к суммарному объему входных и выходных данных. Она показывает, сколько операций приходится на единицу переданных данных. Несмотря на простоту данного понятия, это значение исключительно полезно на практике: чем выше вычислительная мощность, тем меньше накладных расходов вызывает перемещение данных для их обработки, например, на сопроцессоре, ускорителе или другом узле кластера. Например, вычислительная мощность скалярного произведения двух векторов равна всего лишь <math>1</math>, а вычислительная мощность алгоритма умножения двух квадратных матриц равна <math>2n/3</math>.

EM-алгоритм не является устойчивым, результат его работы сильно зависит от начальных приближений параметров. При неудачном выборе начальных приближений алгоритм может не сойтись или сойтись в локальный экстремум.

Также, алгоритм не является детерминированным. Так как в начале работы алгоритма происходит инициализация начальных параметров случайным образом (с учетом положительной определенности и симметричности матрицы ковариации), он не может быть детерминирован.

Алгоритм сбалансирован по E и M шагам, затраты на выполнение этих этапов примерно одинаковы.

= ЧАСТЬ. Программная реализация алгоритма =

== Особенности реализации последовательного алгоритма ==
В данном разделе приведем код реализации последовательного алгоритма.

<source lang="c++">
double_vector em_algo::expectation_step(double_matrix& features)
{
long n_objects = features.size1();
int n_clusters = parameters.sigmas.size();
double pi = boost::math::constants::pi<double>();

// precalculate inverse matrices and dets
std::vector<double_matrix> sigmas_inverted(n_clusters);
std::vector<double> norm_distribution_denominator(n_clusters);
for (int i = 0; i < n_clusters; ++i)
{
double_matrix sigma_inverted(parameters.sigmas[i].size1(), parameters.sigmas[i].size2());
double det = InvertMatrix(parameters.sigmas[i], sigma_inverted);
if (det == 0)
{
std::cerr << "Matrix can not be inverted\n";
exit(1);
}
norm_distribution_denominator[i] = sqrt(pow(2 * pi, parameters.n_features) * det);
sigmas_inverted[i] = sigma_inverted;
}

hidden_vars = double_matrix(n_objects, n_clusters);
double_vector log_likelihood(n_objects, 0);

for (auto i = 0; i < n_objects; ++i)
{
double_matrix_row x(features, i);
double norm_value = 0;
for (auto j = 0; j < n_clusters; ++j)
{
double_matrix_column current_means(parameters.means, j);
double_vector x_centered = x - current_means;

double exp_power = -0.5 * inner_prod(prod(x_centered, sigmas_inverted[j]), x_centered);
hidden_vars(i, j) = parameters.weights(j) * exp(exp_power) / norm_distribution_denominator[j];

norm_value += hidden_vars(i, j);
}
double_matrix_row hidden_vars_row(hidden_vars, i);
if (norm_value != 0)
{
hidden_vars_row = hidden_vars_row / norm_value;
log_likelihood(i) = log(inner_prod(hidden_vars_row, parameters.weights));
}

}
return log_likelihood;
}

void em_algo::maximization_step(double_matrix& features)
{
int n_objects = features.size1();

double_vector w = double_vector(n_clusters, 0.0);
double_matrix means = double_matrix(parameters.n_features, n_clusters, 0.0);
std::vector<double_matrix> sigmas;
for (int j = 0; j < n_clusters; ++j)
sigmas.push_back(double_matrix(parameters.n_features, parameters.n_features, 0.0));

for (int i = 0; i < n_objects; ++i)
{
double_matrix_row x_i = row(features, i);

for (int j = 0; j < n_clusters; ++j)
{
double g = hidden_vars(i, j);
w(j) += g;

double_matrix_column single_mean = column(means, j);

single_mean += g * x_i;

double_vector x_centered = x_i - column(parameters.means, j);
for (int k = 0; k < parameters.n_features; ++k)
for (int l = 0; l < parameters.n_features; ++l)
sigmas[j](k, l) = sigmas[j](k, l) + g * x_centered(k) * x_centered(l);
}
}
// update weights
parameters.weights = w / n_objects;

for (int j = 0; j < n_clusters; ++j) {
double weight = w(j);
// update means
double_matrix_column means_old = column(parameters.means, j);
double_matrix_column means_new = column(means, j);
means_old = means_new / weight;

// update sigmas
parameters.sigmas[j] = sigmas[j] / weight;
for (int k = 0; k < parameters.n_features; ++k)
parameters.sigmas[j](k, k) = parameters.sigmas[j](k, k) + tol;
}
}

bool em_algo::is_likelihood_stabilized(double_vector likelihood, double_vector previous_likelihood)
{
double likelihood_diff = sum(likelihood) - sum(previous_likelihood);
return fabs(likelihood_diff) < tol;
}

model em_algo::process(double_matrix& features, int max_iterations)
{
int iteration = 0;
double_vector likelihood, previous_likelihood;
while (iteration++ < max_iterations && (iteration <= 2 || !is_likelihood_stabilized(likelihood, previous_likelihood)))
{
previous_likelihood = likelihood;
likelihood = expectation_step(features);
maximization_step(features);
}
return parameters;
}
</source>

Возможной реализацией является перестановка местами циклов по объектам и по кластерам на E и М шаге. В данном случае внешний цикл проходит по объектам, так как подразумевается дальнейшая реализации распараллеливания по объектам. При реализации только последовательного алгоритма более понятной версией будет реализация внешнего цикла по кластерам, и внутреннего по объектам, но такая реализация увеличит число обращений в память и общее время работы алгоритма.

== Локальность данных и вычислений ==

== Возможные способы и особенности параллельной реализации алгоритма ==

== Масштабируемость алгоритма и его реализации ==
===Масштабируемость реализации алгоритма===
Для проведения экспериментов по масштабируемости были выбраны следующие параметры алгоритма: были зафиксированы число кластеров <math>k = 4 </math>, и, также, было зафиксировано ядро рандомизации, чтобы избавиться от случайности различного выбора начального приближения параметров. Для показательности результатов условие дострочного завершения работы алгоритма в случае стабилизирования логарифма правдоподобия игнорировалось, и для каждого запуска проводилось 50 итераций EM-алгоритма.

Для экспериментов было сгенерировано 20 выборок разного размера: от 40000 объектов до 200000 с шагом в 10000. Для каждой выборки время работы алгоритма усреднялось по нескольким запускам, чтобы избежать выбросов.

Для работы с многопоточностью использовалась библиотека OpenMP. С помощью нее были распараллелены основные циклы по объектам на E и M шаге.

Эксперименты проводились на компьютере с процессором Intel(R) Core(TM) i7-5820K @ 3.30GHz, который поддерживает до 12ти потоков.

Как видно на рис. 4, производительность растет до 12 процессов, после чего время работы алгоритма снова начинает увеличиваться, то есть использование более 12 процессов при рассматриваемой конфигурации процессора не имеет смысла. Заметим также, что в увеличением числа точек, скорость работы программы линейно увеличивается.

[[file:EM performance.png|thumb|center|700px|Рис. 4 Время работы EM алгоритма в зависимости от числа процессов и размера задачи]]

В результате проведённых экспериментов был получен следующий диапазон эффективности реализации алгоритма:

* минимальная эффективность реализации 0,00072%;
* максимальная эффективность реализации 25.5037%.

[[file:EM_Efficiency.png|thumb|center|700px|Рис. 4 Эффективность EM алгоритма в зависимости от числа процессов и размера задачи]]

== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Существуют следующие последовательные реализации EM-алгоритма для кластеризации: [http://docs.opencv.org/2.4/modules/ml/doc/expectation_maximization.html# opencv], [http://scikit-learn.org/stable/modules/mixture.html scikit-learn].

Также существует несколько параллельных реализаций, описанных в следующих статьях:

В статье <ref>López-de-Teruel P. E., García J. M., Acacio; The Parallel EM Algorithm and its Applications in Computer Vision</ref> авторы предлагают распределить вычисление скрытых переменных для каждого объекта между процессорами и на каждой итерации производить нормализацию. M-шаг предлагается параллелить по компонентам, что требует реализации корректного взаимодействия между процессорами. Предложенный вариант распараллеливания был реализован и протестирован авторами статьи с помощью MPI библиотеки MPICH.

Авторы статьи <ref>Abhinandan Das, Mayur Datar, Ashutosh Garg; Google News Personalization: Scalable Online Collaborative Filtering
[[en:Description of algorithm properties and structure]]</ref> используют MapReduce для распараллеливания EM-алгоритма для PLSI моделей.

= Литература =

<references \>

Участник:ЕкатеринаКозырева/Алгоритм динамической иерархической кластеризации CHAMELEON

2016-11-01T10:43:27Z

Algoman:

{{Assignment|Algoman}}

{{algorithm
| name = Алгоритм динамической иерархической кластеризации CHAMELEON
| serial_complexity = <math>O(nm + n log n + m^2 log m)</math>
| input_data = <math>\frac{n (n - 1)}{2}</math>
| output_data = <math>n</math>
| pf_height = <math>O(n+ n log(n) + m^2 log (m) + m log(m))</math>
| pf_width = <math>O(n)</math>
}}

Автор описания [[Участник:ЕкатеринаКозырева|Е.А.Козырева]]
= Свойства и структура алгоритмов =

== Общее описание алгоритма ==
Алгоритм CHAMELEON был предложен в 1999 году тремя учеными из университета Миннесоты – George Karypis, Eui-Hong (Sam) Han и Vipin Kumar<ref>George Karypis, Eui-Hong (Sam) Han и Vipin Kumar, «Chameleon: Hierarchical Clustering Using Dynamic Modeling», 1999.</ref>.

Предназначен для решения задач кластеризации. Кластеризация (или кластерный анализ) — это задача разбиения множества объектов на группы, называемые кластерами. Внутри каждой группы должны оказаться «похожие» объекты, а объекты разных группы должны быть как можно более отличны.

CHAMELEON - это агломеративный иерархический алгоритм кластеризации, ключевой особенностью которого является то, что он учитывает и взаимную связность, и сходство при определении наиболее похожей пары подкластеров, основываясь на динамической модели. Это означает, что в процессе кластеризации два кластера объединяются, только если их относительная взаимная связность и относительное взаимное сходство являются высокими по отношению к внутренней взаимосвязанности кластеров и близости элементов внутри кластеров. Кроме того, CHAMELEON использует подход для моделирования степени взаимосвязанности и близости между каждой парой кластеров, который учитывает внутренние характеристики самих кластеров. Таким образом, он может автоматически адаптироваться к внутренним характеристикам объединяемых кластеров.

CHAMELEON находит кластеры в наборе данных с помощью трехфазного алгоритма. На первой фазе происходит построение графа, путём добавления рёбер по принципу k ближайших соседей. На второй фазе CHAMELEON группирует полученные элементы в множество относительно небольших подграфов. Во время третьей фазы применяется агломеративный иерархический алгоритм кластеризации, с помощью которого находятся естесственные кластеры путем многократного объединения подграфов, полученных на прошлом этапе.

[[File:Chameleon.png|1000px|thumb|center|Рисунок 1. Общая структура алгоритма CHAMELEON]]

== Математическое описание алгоритма ==

''Исходные данные'':

* Множество из n точек <math>V= {v_{ij}}</math> в метрическом пространстве, которое задано симметрической матрицей расстояний <math>A</math> размера <math>n\times n</math>.
* <math>k</math> - количество ближайших соседей для вершин, <math>k \in N, k \leq n</math>.
* <math>l</math> - наименьшее число вершин, которое может содержать наибольший подграф на 2-м этапе, <math>l \in N, l \leq n</math>.

''Обозначения'':

* <math>G = (V, E)</math> - граф, полученный путём соединения каждой точки с её <math>k</math> ближайшими соседями.

* <math>K= \{K_{i}\}</math> - разбиение множества <math>V</math> на набор попарно непересекающихся связных подмножеств, полученное в результате выполнения второй фазы алгоритма.

* <math>G_{2} = (K, E_{2})</math> - взвешенный граф, вершинами которого являются получившиеся подграфы, а ребрами - количество ребер исходного графа, соединяющих соответствующие подграфы.

* <math>C = \{C_{i}\}</math> - итоговое разбиение множества вершин графа <math>G_{2}</math> на набор кластеров.

''Вспомогательные понятия''

*<math>EC_{(C_{i},C_{j})}</math> - абсолютная взаимная связность пары кластеров <math>C_{i}, C{j}</math>. Определяется как сумма весов ребер, соединяющих вершины, принадлежащие <math>C{i}</math> c вершинами из <math>C{j}</math>. Внутренняя связность <math>EC_{(C_{i},C_{i})}</math> вычисляется как сумма ребер, входящих в разделитель, разбивающий <math>C{i}</math> на два равных подграфа.

*<math>RI_{(C_{i},C_{j})} = \frac{|EC_{(C_{i},C_{j})}|}{(|EC_{C_{i}}|+|EC_{C_{j}}|)/2}</math> - относительная взаимная связность пары кластеров <math>C_{i}, C{j}</math>

*<math>S_{EC_{(C_{i},C_{j})}}</math> - абсолютное взаимное сходство пары кластеров <math>C_{i}, C{j}</math>. Подсчитывается как среднее сходство между соединенными вершинами, принадлежащими <math>C{i}</math> и <math>C{j}</math> соответственно. Соединения обусловлены разбиением общего графа, полученного на первом этапе алгоритма.

*<math> RC_{(C_{i},C_{j})}= \frac{S_{EC_{(C_{i},C_{j})}}}{\frac{|C_{i}|}{|C_{i}+C_{j}|}*S_{EC_{(C_{i})}}+\frac{|C_{i}|}{|C_{i}+C_{j}|}*S_{EC_{(C_{j})}}}</math> - относительное взаимное сходство пары кластеров <math>C_{i}, C{j}</math>. Определяется как абсолютное сходство между этой парой кластеров, нормализованное с учетом их внутреннего сходства<ref>http://studopedia.ru/7_41934_algoritm-dinamicheskoy-ierarhicheskoy-klasterizatsii-CHAMELEON.html</ref>.

'''Первый этап'''

На первом этапе, согласно графо-ориентированному подходу, происходит построение графа <math>G = (V, E)</math> на матрице сходства объектов по принципу k ближайших соседей. Две вершины такого графа соединяет ребро, если объект, соответствующий любой из этих вершин попадает в число k наиболее близких объектов для объекта, соответствующего другой вершине из данной пары.
[[Файл:Снимок chameleon 2.png|2000px|thumb|Рисунок 2. Объекты в пространстве - слева, граф по принципу 1-го ближайшего соседа - по центру, граф по принципу 3-х ближайших соседей - справа ]]

'''Второй этап'''

Алгоритм разделяет полученный граф на множество сравнительно малых подграфов <math>K= \{K_{i}\}</math>. Разделение происходит последовательно. На каждом шаге выбирается подграф, содержащий наибольшее число вершин. Этот граф разделяется на два подграфа так, что разделитель ребер графа минимален и каждый из получаемых подграфов содержит не менее 25 % вершин исходного графа. Процесс разделения останавливается, когда наибольший подграф содержит меньше некоторого заданного числа вершин. Обычно величина этого параметра задается равной значению от 1 до 5 % от числа объектов. Полученное множество связных графов считается множеством начальных кластеров, на котором требуется провести последовательное иерархическое объединение.

'''Третий этап'''

Третий этап заключается в итеративном преобразовании множества подграфов <math>K= \{K_{i}\}</math> в множество кластеров <math>C = \{C_{i}\}</math>. Алгоритм осуществляет агломеративную иерархическую кластеризацию на основании показателей <math>EC_{(C_{i},C_{j})}</math>, <math>S_{EC_{(C_{i},C_{j})}}</math>, <math>RI_{(C_{i},C_{j})} </math>, <math> RC_{(C_{i},C_{j})}</math>. Существует две стратегии анализа показателей сходства. Первая подразумевает наличие некоторых пороговых значений <math>T_{RI}</math> и <math>T_{RC}</math>. В соответствии с этой стратегией, алгоритм для каждого кластера <math>C_{i}</math> проверяет, отвечают ли смежные (наиболее близкие) ему кластеры условиям:

*<math>RI_{(C_{i},C_{j})} \geqslant T_{RI}</math>

*<math>RC_{(C_{i},C_{j})} \geqslant T_{RC}</math>

Если более одного смежного кластера отвечает этим условиям, то алгоритм выбирает для объединения наиболее связный кластер (граф), то есть такой кластер <math>C_{j}</math>, с которым у кластера <math>C_{i}</math> получается наибольшая абсолютная взаимная связность. По завершению прохода по всем кластерам, созданные таким образом пары объединяются. Параметры <math>T_{RI}</math> и <math>T_{RC}</math> могут использоваться для изменения характеристик получаемых кластеров.

Вторая стратегия заключается в использовании специальной функции, объединяющей понятия относительной взаимной связности и относительного взаимного сходства. На каждом шаге выбираются те кластеры для объединения, которые максимизируют эту функцию:

<math>RI_{(C_{i},C_{j})}*RC_{(C_{i},C_{j})}^\alpha</math>,

где <math>\alpha</math> выбирается пользователем. Если <math>\alpha > 1 </math>, то алгоритм придает большее значение относительному взаимному сходству, а если <math>\alpha < 1 </math>, то большее значение имеет относительная взаимная связность.

''Вычисляемые данные'':

<math>U = (u_1, u_2, ..., u_n)</math> - n-мерный вектор, где <math>u_i \in N_{[C]}</math> - порядковый номер кластера, к которому принадлежит вершина i исходного множества V.

== Вычислительное ядро алгоритма ==

Алгоритм имеет три вычислительных ядра, по одному на каждый этап.

На первом этапе вычислительным ядром является процесс нахождения <math>k</math> ближайших соседей для каждой вершины, который заключается в анализе матрицы расстояний.

На втором этапе вычислительным ядром является процесс поиска подходящего разбиения очередного подграфа на два графа с минимизацией разделителя ребер графа.

На третьем этапе вычислительным ядром является расчет величин <math>EC_{(C_{i},C_{j})}</math>, <math>S_{EC_{(C_{i},C_{j})}}</math>, <math>RI_{(C_{i},C_{j})} </math>, <math> RC_{(C_{i},C_{j})}</math> для каждой пары смежных кластеров.

== Макроструктура алгоритма ==

Как уже рассказывалось ранее, алгоритм включает в себя три основных этапа, каждый из которых, по сути, является отдельным алгоритмом. Этапы выполняются последовательно относительно друг друга.

Макрооперация на первом этапе - процедура нахождения <math>k</math> ближайших соседей, на втором - процедура разбиения наибольшего подграфа на два графа, на третьем - процедура вычисления показателей сходства, на основе которых принимается решение о слиянии подграфов в кластер.

== Схема реализации последовательного алгоритма ==

'''Первый этап'''
<source lang="cpp">
int n; //количество вершин
int k; //количество соседей
int A[n][n] //матрица расстояний
int D[k] //массив вершин-соседей
int E[n][n] //матрица ребер графа <math>G_{2} = (K, E_{2})</math>
for i=1 to n-1 do
{
for j=i+1 to n do
{
//заполняем массив вершин-соседей вставляя новые вершины, если они ближе, чем самая далекая из массива.
}
for j=0 to k do
{
//для каждой вершины соседа заполняем соответствующую ячейку из матрицы E[n][n] единицей
}

}
</source>

'''Второй этап'''

1. Все связные подграфы в отсортированном порядке помещаются в список;
2. Берем наибольший элемент списка, вычисляем количество его вершин. Если число вершин > l, то идем в пункт 3. Иначе в пункт 5;
3. Разбиваем подграф на два подграфа таким образом, чтобы разделитель ребер графа был минимален и каждый из получаемых подграфов содержал не менее 25 % вершин исходного графа;
4. Добавляем полученные элементы в список подграфов таким образом, чтобы список оставался отсортированным. Идем в пункт 2;
5. Нашли искомое множество подграфов math>K = \{K_{i}\}</math>;
6. Создаем и заполняем матрицу матрицу расстояний для графа <math>G_{2} = (K, E_{2})</math>. Получаем искомый набор рёбер <math>E_{2}</math>.

'''Третий этап'''

1. Заводим два массива: а) массив кластеров C, полученных на предыдущем этапе, б) массив объединений кластеров F, которые мы будем получать на этом этапе;
2. Берем следующий кластер <math>C_{i}</math> (на первом шаге - первый). Если все кластеры просмотрены, идем в пункт 6;
3. Берем следующий кластер <math>C_{j}, i<>j</math>. Если все кластеры просмотрены, то идем в пункт 2;
4. Проверяем смежность <math>C_{i}</math> и <math>C_{j}</math>. Если не смежны, то возвращаемся в пункт 3. Если смежны, идем в пункт 5;
5. Рассчитываем показатели <math>RI_{(C_{i},C_{j})}</math> и <math> RC_{(C_{i},C_{j})}</math>. Проверяем, удовлетворяют ли найденные значения условиям:
*<math>RI_{(C_{i},C_{j})} \geqslant T_{RI}</math>
*<math>RC_{(C_{i},C_{j})} \geqslant T_{RC}</math>
Если нет, то идем в пункт 3. Иначе если смежность пары кластеров выше, чем у предыдущих найденных, то <math>F_{i}=j</math>. Идем в пункт 3;
6. Если в списке F есть хотя бы одна пара кластеров для слияния, то выполняем слияние, обновляем массив кластеров и массив объединений кластеров. Идем в пункт 2.

== Последовательная сложность алгоритма ==

1) Для построения графа на основе метода k ближайших соседей для n вершин требуется <math>O(n log(n))</math> операций <ref>J.H. Friedman, J.L. Bentley, and R.A. Finkel. An algorithm for ﬁnding best matches in logarithmic expected time. ACM Transactions on Mathematical Software, 3:209–226, 1977.</ref>; для наборов данных большой размерности эта величина составляет <math>O(n^2)</math> операций <ref>S. Berchtold, C. Bohm, D. Keim, and H.-P. Kriegel. Cost model for nearest neighbor search in high dimensional data space. In Proc. of Symposium on Principles of Database Systems, Tucson, Arizona, 1997.</ref>;

2) Для выделения множества сравнительно малых связных подграфов требуется <math>nm</math> операций, где <math>m</math> - количество подграфов, полученных на втором этапе алгоритма;

3) Формирование набора кластеров, на основе множества подграфов, полученных на предыдущем этапе, требует <math>m^2log(m)</math> операций.

Итого, для n вершин получаем последовательную сложность <math>O(n log(n)+nm+m^2log(m))</math>.

== Информационный граф ==
[[File:СК.png]]

== Ресурс параллелизма алгоритма ==

Первый этап работы алгоритма можно распределить между <math>n</math> процессами. На вход каждому процессу подается своя вершина, далее происходит процедура поиска <math>k</math> ближайших соседей. Параллельная сложность составляет <math>O(n)</math>.

Второй и третий этапы можно распараллелить частично.

Второй этап распараллеливается путем подачи на вход свободному процессу очередного подграфа для разделения. Число итераций оценивается в <math>O(n log(n))</math>.

Третий этап делится на расчет показателей схожести и соединение подграфов в кластеры. Процесс расчета показателей можно распараллелить, подавая каждому процессу на вход пару подграфов. Сложность этого процесса оценивается как <math>m log(m)</math>. Соединение подграфов в кластеры выполняется последовательно, сложность процесса составляет <math>m^2 log(m)</math>

Таким образом получаем общую параллельную сложность алгоритма: <math>O(n+ n log(n) + m^2 log (m) + m log(m))</math>

== Входные и выходные данные алгоритма ==
'''Входные данные'''

1. Симметрическая матрица <math>A</math> расстояний между элементами данных размера <math>n\times n</math> с нулями на главной диагонали (<math>a_{ii}= 0, i = 1, \ldots, N</math>).

2. <math>k</math> - количество ближайших соседей для вершин (рекомендуемое значение <math>k</math> от 5 до 20 в зависимости от количества анализируемых объектов).

3. <math>l</math> - наименьшее число вершин, которое может содержать наибольший подкластер на 2-м этапе . Величина этого параметра варьируется от 1 до 5 % от общего числа объектов.

'''Объём входных данных'''

<math>\frac{n (n - 1)}{2}</math> (в силу симметричности и нулевой главной диагонали достаточно хранить только над/поддиагональные элементы).

'''Выходные данные'''

Вектор из <math>n</math> чисел <math>u_{1}, u_{2}, \ldots, u_{N}</math>, где <math>u_{i}</math> - целое число, соответствующее кластеру <math>i</math>-го объекта.

'''Объём выходных данных'''

<math>n</math>

== Свойства алгоритма ==
Соотношение последовательной и параллельной сложности на первом этапе является ''линейным'' для больших наборов данных и логарифмическим для n вершин. На втором этапе сложно оценить это соотношение - оно сильно зависит от параметров <math>k</math> и <math>l</math>. На третьем этапе соотношение равно <math>O(1)</math>;

Оценка ''вычислительной мощности'' выглядит следующим образом:

<math>O(1)</math> для 1-го этапа;

<math>O(\frac{nm}{n^2+m^2})</math> для 2-го этапа;

<math>O(\frac{m^2log(m)}{m^2+n})</math> для 3-го этапа;

Алгоритм является ''недетерминированным''. Хотя 1-й этап детерминирован, на 2-ом этапе могут быть найдены различные разбиения на подграфы, что повлияет и на итоговый результат работы алгоритма.

= Программная реализация алгоритма =
== Особенности реализации последовательного алгоритма ==
== Локальность данных и вычислений ==
== Возможные способы и особенности параллельной реализации алгоритма ==
== Масштабируемость алгоритма и его реализации ==

см. позднее

== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Последовательная реализация алгоритма доступна по ссылке <ref>http://www.codeforge.com/article/192925</ref>.

CHAMELEON можно реализовать с использованием графовых библиотек METIS <ref>http://glaros.dtc.umn.edu/gkhome/metis/metis/overview
</ref>, hMETIS <ref>http://glaros.dtc.umn.edu/gkhome/metis/hmetis/overview</ref> и RANN <ref>https://cran.r-project.org/web/packages/RANN/index.html</ref>.

Существует исследование, связанное с реализацией CHAMELEON посредством технологии OpenMP, с которым можно ознакомиться здесь <ref>http://research.ijcaonline.org/volume79/number8/pxc3891600.pdf</ref>.

Параллельных реализаций алгоритма CHAMELEON не найдено.

= Литература =

Участница:Александра/Метод встречи посередине

2016-10-31T14:10:43Z

Algoman:

{{Assignment|Algoman}}

{{algorithm
| name = Метод встречи посередине
| serial_complexity = <math>O(\sqrt n\log(n))</math>
| pf_height = <math>O(1)</math>
| pf_width = <math>O(n)</math>
| input_data = <math>O(n)</math>
| output_data = <math>n</math>
}}

Автор описания: [[Участник:Александра|А.В.Батарина]]

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===
Метод "Встреча посередине" криптоанализа блочных шифров был впервые предложен в 1977 году Уитфилдом Диффи и Мартином Хеллманом <ref>(June 1977) «Exhaustive Cryptanalysis of the NBS Data Encryption Standard». Computer 10 (6): 74–84. DOI:10.1109/C-M.1977.217750</ref>. Встреча посередине используется для ускорения перебора ключей шифра за счёт увеличения требуемой памяти. Метод применим в случае каскадного построения сложного шифра из нескольких простых, другими словами, в случае последовательного применения шифрующих преобразований на разных ключах к блокам открытого текста.

В качестве примера шифра, поддающегося атаке "встреча посередине" можно привести криптоалгоритм 2DES, являющийся модификацией шифра DES. В 2DES открытый текст шифруется дважды алгоритмом DES на двух разных 56-битных ключах. Однако из-за атаки "встреча посередине" сложность перебора двойного ключа (112 бит) шифра 2DES составляет <math>2^{57}</math> вместо ожидаемых <math>2^{112}</math>.

=== Математическое описание алгоритма ===

'''Исходные данные:''' открытый текст <math>x</math>, шифртекст <math>y</math>.

Алгоритм зашифрования — композиция двух преобразований <math>T_1(x,k_1)</math> и <math>T_2(x,k_2)</math>, т.е. <math>y=T_2(T_1(x,k_1),k_2)</math>.

Алгоритм расшифрования — <math>y=T_1^{-1}(T_2^{-1}(x,k_2),k_1)</math>

'''Вычисляемые данные:''' ключи шифрования <math>k_1 \in K_1</math>, <math>k_2 \in K_2</math>, где <math>K_1, K_2</math> — множества возможных ключей.

Трудоёмкость полного перебора всех возможных пар <math>k_1,k_2</math> составляет в среднем <math>\frac{|K_1||K_2|}{2}</math>, а в худшем случае <math>|K_1||K_2|</math>. Однако используя дополнительную память, можно сократить перебор.

Предположим, что открытый текст <math>x</math> и шифртекст <math>y</math> однозначно определяют ключи <math>k_1,k_2</math>. Составим две таблицы:

<math>
\begin{align}
z_1 & =T_1(x,k_1^1) & z_1^' &=T_2^{-1}(x,k_2^1)\\\\
z_2 & =T_1(x,k_1^2) & z_2^' & =T_2^{-1}(x,k_2^2)\\
... & ................. & ... & .................... \\
z_{|K_1|} & =T_1(x,k_1^{|K_1|}) & z_{|K_1|}^' & =T_2^{-1}(x,k_2^{|K_1|})
\end{align}
</math>

Для всех <math>k_1^i \in K_1</math>, <math>k_2^j \in K_2</math>. Далее таблицы объединяются и сортируются по значениям <math>z_i,z_j^'</math>. Индексы <math>i,j</math>, при которых <math>z_i=z_j^'</math>, однозначно определяют искомую пару ключей <math>k_1=k_1^i,k_2=k_2^j</math>. Для нахождения такой пары достаточно просмотреть отсортированную таблицу один раз.

Если же пара открытый текст/шифртекст определяет ключ не единственном образом, то выходом алгоритма будет некоторое множество пар <math>k_1,k_2</math>, одна из которых является истинным ключом. Для выбора истинного ключа достаточно проверить ключи из полученного множества на других парах открытый текст/шифртекст.

==== Оптимизации ====

1. От генерации второй таблицы со значениями <math>z_j^'</math> можно отказаться, перебирая ключи <math>k_2^j</math> до того момента, когда значение <math>z_j^'</math> совпадёт с одним из значений <math>z_i</math>. В таком случае опробование ключей <math>k_2^j</math> в среднем сократится вдвое. Также вдвое сократится объём используемой памяти. Для нахождения совпадающего значения в отсортированном массиве можно применить бинарный поиск.

2. Вместо сортировки таблицы со значениями <math>z_i</math> и последующего бинарного поиска можно использовать хэш-таблицу.

=== Вычислительное ядро алгоритма ===
В случае использования хэш-таблицы достаточно большого размера основную сложность алгоритма составляет опробование ключей <math>k_1,k_2</math>.
Одним из самых трудоёмких шагов также оказывается сортировка таблицы.

=== Макроструктура алгоритма ===

Как видно из описания, атака "встреча посередине" использует (или может использовать в качестве оптимизации) следующие алгоритмы:

1. Алгоритм зашифрования/расшифрования

2. Алгоритм сортировки

3. Алгоритмы поиска, вставки в хэш-таблицу

=== Схема реализации последовательного алгоритма ===

Далее приводится последовательность действий для варианта алгоритма с генерацией одной таблицы значений <math>z_i</math>.

1. Вычислить таблицу <math>z_i</math>, записывая значения в порядке вычисления или используя хэш-таблицу

2. В случае записи значений в порядке вычисления отсортировать массив

3. Опробовать ключи <math>k_2^j</math>, ища совпадения с таблицей значений <math>z_j^'</math>. Для нахождения совпадения использовать поиск по хэш-таблице (если она есть) или бинарный поиск

=== Последовательная сложность алгоритма ===
Всюду далее считаем, что алгоритм не прекращает работу при нахождении первого совпадения, а ищет все совпадения.

1. Сложность вычисления таблиц значений <math>z_i,z_j^'</math> составит <math>O(|K_1|+|K_2|)</math> операций опробования

2. Объединение таблиц и их сортировка будет иметь сложность <math>O((|K_1|+|K_2|)\log(|K_1|+|K_2|))</math> (например, при сортировке слиянием).

3. Сложность бинарного поиска в отсортированном массиве — <math>O(log_2(|K_1|))</math> для каждого поиска

4. Сложность поиска в достаточно большой хэш-таблице составит <math>O(1)</math> для каждого поиска

Итого асимптотическая сложность алгоритма:

1. С генерацией двух таблиц — <math>O(|K_1|+|K_2|) + O((|K_1|+|K_2|)\log(|K_1|+|K_2|)) + O(|K_1|+|K_2|)=O((|K_1|+|K_2|)\log(|K_1|+|K_2|))</math>

2. C генерацией одной таблицы, сортировкой и бинарным поиском — <math>O(|K_1|) + O((|K_1|)\log(|K_1|)) + O(|K_2|\log_2(|K_1|))=O(max(|K_1|,|K_2|)\log(|K_1|))</math>

3. C генерацией одной (достаточно большой) хэш-таблицы — <math>O(|K_1|) + O(|K_2|)=O(|K_1|+|K_2|)</math>

Пусть n - количество всевозможных пар <math>k_1,k_2</math> и пусть <math>|K_1|=|K_2|</math>. В этом случае <math>|K_1|=|K_2|=\sqrt n</math>.

Тогда сложность алгоритма в первых двух пунктах составляет <math>O(\sqrt n\log(n))</math>, в третьем — <math>O(\sqrt n)</math>.

=== Информационный граф ===

Опишем информационный граф алгоритма. На вход подаётся открытый (Open) и закрытый (Close), т.е. зашифрованный, текст. Далее открытый текст шифруется (Enc) на ключах <math>k_1^i</math>, а зашифрованный расшифровывается (Dec) на ключах <math>k_2^j</math>. Далее полученные криптограммы сравниваются (Cmp) и все ключи, на которых они совпали, являются выходом алгоритма.

[[file:meet.png|thumb|center|1040px|Рисунок 1. Граф алгоритма c отображением входных и выходных данных. Open — открытый текст, Close — шифртекст, Enc — операция зашифрования, Dec — операция расшифрования, Cmp — операция сравнения, Keys — вычисленные ключи]]

=== Ресурс параллелизма алгоритма ===

Как видно из информационного графа, для реализации атаки "встреча посередине" в параллельном варианте потребуются выполнение следующих двух ярусов (в предположении, что <math>|K_1|=|K_2|</math>):

1. <math>\sqrt n</math> зашифрований и столько же расшифрований

2. <math>n</math> сравнений

Таким образом, высота ЯПФ составляет 2, ширина - <math>n</math>.

=== Входные и выходные данные алгоритма ===

'''Вход:'''
На вход подаётся открытый текст <math>x</math> и шифртекст <math>y</math>, а также алгоритм зашифрования/расшифрования. В случае блочного шифра открытым текстом и шифртекстом является последовательность блоков. Для атаки "встреча посередине", как правило, берётся один блок для максимального ускорения операций зашифрования и расшифрования.

'''Выход:'''
Результатом работы алгоритма является множество пар <math>k_1^i,k_2^j</math>, для которых нашлись совпадения. Только одна из пар является настоящим ключом. Чтобы отсеять лишние, необходимо проверить все пары на блоках открытого и шифрованного текста, которые в алгоритме не использовались.

=== Свойства алгоритма ===
Соотношением последовательной и параллельной сложности алгоритма является <math>O(\sqrt n\log(n))</math>.

Будем считать, что размер входных данных (открытый текст и шифртекст) совпадает с размером ключа (на практике это сравнимые величины), а сортировка слиянием делит массивы пополам. Тогда вычислительная мощность алгоритма — <math>O(\sqrt n)</math>.

Дуги информационного графа, исходящие из вершин зашифрования и расшифрования, образуют пучки мощности <math>\sqrt n</math>, т.е. из каждой такой вершины выходит <math>\sqrt n</math> дуг. Длинных дуг в алгоритме нет. В случае поиска всех пар ключей с совпадающими криптограммами алгоритм полностью детерминирован.

== Программная реализация алгоритма ==

=== Особенности реализации последовательного алгоритма ===

=== Локальность данных и вычислений ===

=== Возможные способы и особенности параллельной реализации алгоритма ===

=== Масштабируемость алгоритма и его реализации ===

=== Динамические характеристики и эффективность реализации алгоритма ===

=== Выводы для классов архитектур ===

=== Существующие реализации алгоритма ===

Одна из реализаций атаки "встреча посередине" с использованием хэш-таблицы представлена в свободном доступе по ссылке [https://gist.github.com/dchest/1062437 github]

== Литература ==

<references \>

Обсуждение участника:Мария Готман

2016-10-31T14:04:17Z

Algoman:

== Замечания к [[Алгоритм_кластеризации,_основанный_на_максимизации_ожидания]] ==

1) список литературы лучше оформить средствами разметки - см. как сделано в [[Разложение_Холецкого_(метод_квадратного_корня)]]

Список литературы исправлен.

== Замечения от 31.10 ==

"- В конце статьи должен быть приведен список всех источников, откуда бралась информация по алгоритму. Если вы используется готовый рисунок, то сслыку на источник нужно разместить либо в подписи к рисунку, либо в тексте, где стоит ссылка на рисунок."

какой источник картинок с графиками (п1.1 и 2.4)? созданы ли они авторами для этой статьи, публиковались ли где-то ещё?

Участник:Noite/EM-алгоритм кластеризации

2016-10-31T14:03:40Z

Algoman:

{{Assignment|Algoman}}

{{algorithm
| name = EM-алгоритм кластеризации
| serial_complexity = <math>O(n * m^2 * k)</math> - одна итерация
| input_data = <math>n * m + 1</math>
| output_data = <math>n</math>
}}

Автор описания: [[Участник:Noite|Зинченко Д.А.]]

= Свойства и структура алгоритма =
== Общее описание алгоритма ==
В задачах оптимизации EM-алгоритмом называют итеративную процедуру поиска численного значения экстремума какой-либо функции. В частности, в статистике этот алгоритм используется для оценки максимального правдоподобия. Впервые название EM-алгоритм было предложено в 1977 году<ref>A. Dempster, N. Laird and D. Rubin. Maximum likelihood estimation from incomplete data. – Journal of the Royal Statistical Society, Series B, 1977, vol. 39, p. 1-38.</ref>, однако его идеи были описаны и раньше<ref name=korolev>В.Ю.Королёв. ЕМ-алгоритм, его модификации и их применение к задаче разделения смесей вероятностных распределений.</ref>.

EM-алгоритм применяется для решения задач двух типов <ref name=korolev/>:

# Анализ неполных данных (данных с пропусками).
# Оценка максимального правдоподобия в случае, если функцию правдоподобия трудно исследовать аналитически. В этом случае введение набора скрытых переменных может существенно упростить задачу.

Задача кластеризации относится к задачам второго типа. В данной статье рассматривается следующая постановка задачи кластеризации:

<source>Дано множество объектов, каждый из которых представляет собой точку в n-мерном метрическом пространстве. Каждому измерению пространства соответствует некоторое свойство объекта. Необходимо разбить это множество на k подмножеств так, чтобы, чтобы элементы каждого подмножества существенно отличались по свойствам от элементов других подмножеств.</source>

Использование алгоритма EM подразумевает следующее ''предположение об объектах'':

Пусть объекты, которые необходимо разбить на кластеры, появляются случайным образом и независимо друг от друга согласно вероятностному распределению, равному смеси (линейной комбинации) распределений кластеров. В данной статье в дальнейшем будет считаться, что распределение каждого кластера является многомерным нормальным распределением с произвольной матрицей ковариации - наиболее часто используемое предположение.

Тогда каждый объект принадлежит каждому кластеру, но с разной вероятностью. EM-алгоритм итеративно оценивает параметры распределений кластеров, максимизируя логарифмическую функцию максимального правдоподобия. После окончания работы алгоритма объект будет отнесен к кластеру, вероятность принадлежности которому максимальна. Вводимый набор скрытых переменных для каждого объекта - вероятности того, что объект принадлежит каждому из кластеров.

Итерация алгоритма состоит из двух последовательных шагов.

# (Expectation) Вычисляются новые ожидаемые значения скрытых переменных.
# (Maximization) Решается задача максимизации правдоподобия: По текущим значениям скрытых переменных обновляются параметры распределений для кластеров: математическое ожидание, дисперсия и вероятность появления объектов из кластера.

== Математическое описание алгоритма ==

''Используемые обозначения:''

<math>N</math> - количество объектов, <math>K</math> - количество кластеров, <math>M</math> - количество параметров объекта

<math>\gamma_{n,k}</math> - значения скрытых переменных

<math>N_{k}</math> - количество элементов отнесенных к соответствующему кластеру

<math>x_{1},...,x_n</math> - объекты

''Параметры распределений:''

<math>w_{1},...,w_{k}</math> - вероятности появления объектов из кластеров (веса кластеров), <math>\sum_{k=1}^Kw_{k}=1</math>

<math>\mu_{1},...,\mu_{k}</math> - центры гауссиан кластеров

<math>\Sigma_{1},...,\Sigma_{k}</math> - матрицы ковариации гауссиан кластеров, каждая матрица имеет размерность <math>M</math>x<math>M</math>

''Смесь распределений:''
<center><math> P(x) = \sum_{j=1}^Kw_jp(x|\mu_{j}, \Sigma_{j})</math></center>

Цель алгоритма - вычислить параметры распределений, максимизирующих логарифм функции правдоподобия:

<center><math>\ln P(x|w,\mu,\Sigma)= \sum_{n=1}^N \ln \{ \sum_{k=1}^K w_{k}p(x_{n}|\mu_{k},\Sigma_{k})\}</math>.</center>

* В начале работы алгоритма задаются параметры начального приближения:

<center><math>w_{i} = 1/K, \mu_{i} = random(x_{j}), i=1..K, j=1..N</math></center>

<center><math>\Sigma_{j,j}^{k}=\frac{1}{NK}\sum_{i=1}^N(x_{i,j} - \mu_{k,j})^2, k=1..K, j=1..M</math></center>

''Поскольку от начального приближения может сильно зависеть результат работы алгоритма, вместо инициализации кластеров случайными центрами, равными весами и диагональными матрицами ковариации, как в приведенных формулах, часто применяют другие способы (подробнее - в [[#Особенности реализации последовательного алгоритма | особенностях реализации]])''
* Далее итеративно выполняется следующая пара процедур:
** E-шаг: используя текущее значение параметров <math>w_{1},...,w_{k};\mu_{1},...,\mu_{k};\Sigma^{1},...,\Sigma^{k}</math>, вычисляем значение вектора скрытых переменных <math>\gamma</math>:<center><math>\gamma_{n,k}=\frac{w_{k}p(x_{n}|\mu_{k},\Sigma^{k})}{\sum_{j=1}^K w_{j}p(x_{n}|\mu_{j},\Sigma^{j})}, </math> знаменатель дроби - нормировочный коэффициент</center><center><math>p(x|\mu,\Sigma)=\frac{1}{{(2\pi)}^{\frac{N}{2}}\sqrt{|\Sigma|}}exp\biggl\{-\frac{1}{2}{(x-\mu)}^T{\Sigma}^{-1}(x-\mu)\biggr\}</math> - плотность <math>N</math>-мерного нормального распределения</center>
** М-шаг: переоценка параметров по текущим значениям скрытых переменных для <math>k = 1..K</math>:
<center><math>\mu^{new}_{k}=\frac{1}{N_{k}}\sum_{n=1}^N \gamma_{n,k}x_{n}</math>,</center>

<center><math>\Sigma_{new}^{k}=\frac{1}{N_{k}}\sum_{n=1}^N \gamma_{n,k} (x_{n}-\mu_{k}^{new})(x_{n}-\mu_{k}^{new})^{T}</math>,</center>

<center><math>w_{k}^{new}=\frac{N_{k}}{N}</math>, <math>N_{k}=\sum_{n=1}^N \gamma_{n,k}</math>.</center>

В EM алгоритме используется один из следующих критериев остановки:
*Норма разности векторов скрытых переменных на текущей итерации не превышает заданную константу
*Прошествие заданного количества итераций
*Изменение логарифмического правдоподобия меньше заданной константы.

== Вычислительное ядро алгоритма ==
Вычислительное ядро алгоритма состоит из двух шагов, повторяющихся каждую итерацию:
*Обновление скрытых переменных на основе текущих параметров распределений
*Обновление параметров кластеров: весов, центров и матриц ковариации

== Макроструктура алгоритма ==
Как записано в [[#Вычислительное ядро алгоритма|описании вычислительного ядра алгоритма]], основную часть алгоритма составляют итеративно проводимые макрооперации: Expectation шаг - вычисление новых значений скрытых переменных, Maximization шаг - обновление параметров кластеров. Макроструктура алгоритма представлена на рисунке 1:
[[file:EM_macro.png|thumb|center|600px|Рисунок 1: Макроструктура EM-алгоритма]]

== Схема реализации последовательного алгоритма ==
Примерная схема реализации EM алгоритма с предварительной обработкой матриц ковариации:
<source>
// n - количество объектов

// m - количество координат объектов

// k - количество кластеров

Инициализировать веса и центры кластеров;
Инициализировать матрицы ковариации;

// Основной цикл
Пока условие остановки не выполнено
// E-шаг
В цикле для каждого кластера
Вычислить определитель матрицы ковариации Sigma;
Вычислить обратную матрицу матрице Sigma;
В цикле для каждого объекта
В цикле для каждого кластера
Вычислить и запомнить p(x | mu, Sigma) для текущего объекта и кластера;
Просуммировать вычисленные p(x | mu, Sigma);
В цикле для каждого кластера
Обновить скрытые переменные gamma;
// M-шаг
Обновить веса w;
Обновить центры кластеров mu;
Обновить матрицы ковариации Sigma;
</source>

== Последовательная сложность алгоритма ==

Количество итераций алгоритма зависит от условия остановки, поэтому будем рассматривать сложность одной итерации.

'''Шаг E'''

Сложность вычисления определителя произвольной матрицы ковариации <math>\Sigma</math> методом Гаусса - <math>O(m^3)</math>;

Сложность вычисления матрицы, обратной произвольной матрице ковариации <math>\Sigma</math> методом Гаусса - <math>O(m^3)</math>;

Сложность предварительного вычисления определителей и обратных матриц матрицам ковариации - <math>O(k * m^3)</math>

С учетом заранее вычисленных определителей и обратных матриц сложность вычисления <math>p(x | \mu,\Sigma)</math> составит: <math>O(m^2)</math>;

Суммарно сложность шага E составит <math>O(n * m^2 * k + k * m^3)</math>

'''Шаг M'''

Сложность обновления весов кластеров <math>O(k * n)</math>;

Сложность обновления центров кластеров <math>O(k * m * n)</math>;

Сложность обновления одной матрицы ковариации <math>O(n * m)</math>;

Сложность обновления всех матриц ковариации <math>O(k * m * n)</math>;

Суммарно сложность шага M алгоритма - <math>O(k * m * n)</math>;

Таким образом, сложность одной итерации EM алгоритма для псевдокода, указанного в предыдущем разделе, составит <math>O(k * m^2 * n + k * m^3 + k * m * n)</math>.

В предположении, что размерность объектов много меньше их количества <math>m << n</math> получим сложность итерации <math>O(k * m^2 * n)</math>.

Нетрудно заметить, что вычисление определителя и обратной матрицы к произвольной матрице ковариации составляет большУю часть работы шага E и существенно влияет на его сложность. Поэтому эти вычисления проведены заранее - вынесены за основной цикл шага E<ref name=ParallelEMComparissonGraphLab>Henggang Cui, Jinliang Wei, Wei Dai. Parallel Implementation of Expectation-Maximization for Fast Convergence - School of Computer Science, Carnegie Mellon University. [https://users.ece.cmu.edu/~hengganc/archive/report/final.pdf]</ref>. Помимо этого сложность этих вычислений можно сократить еще сильнее, если ввести ограничения структуру матрицы ковариации <math>\Sigma</math>.

Наиболее часто используемым ограничением, позволяющим эффективно распараллеливать алгоритм<ref>Вячеслав Орешков. EМ — масштабируемый алгоритм кластеризации [https://basegroup.ru/community/articles/em]</ref>, является предположение, что матрица ковариации имеет диагональную форму. Тогда вычисление её определителя и обратной матрицы имеет сложнось <math>O(m)</math>, а суммарная сложность шага E и сложность всей итерации составит <math>O(k * m * n)</math>.

== Информационный граф ==
Макроструктура алгоритма представлена на рисунке 1 (см. [[#Макроструктура алгоритма|раздел 1.4]] статьи).

На рисунке 2 представлена схема вычислений E-шага алгоритма для одного объекта: для объекта <math>x_{i}</math> и параметров <math>w_{j}, \mu_{j}, \Sigma_{j}, j=1..k</math> по формулам [[#Математическое описание алгоритма|раздела 1.2]] вычисляются ненормированные значения скрытых переменных <math>g_{j}</math>, нормировочный коэффициент ''normСoeff'', и получаются итоговые значения <math>\gamma_{i,j}</math>.

[[file:EM_Expectation_step.png|thumb|center|400px|Рисунок 2: E-шаг EM алгоритма для одного объекта]]

На рисунке 3 представлена схема вычислений E-шага алгоритма для всех объектов: для объекта <math>x_{j}</math> и параметров-векторов <math>w, \mu, \Sigma</math> по формулам [[#Математическое описание алгоритма|раздела 1.2]] вычисляются значения скрытых переменных. <math>E_{i}, i=1..n</math> - маркооперации, E-шаги для соответствующих объектов.

[[file:EM_Expectation_step_all.png|thumb|center|400px|Рисунок 3: E-шаг EM алгоритма для всех объектов]]

На рисунке 4 представлена схема вычислений M-шага алгоритма для одного кластера: для объектов <math>x_{i}</math> и скрытых переменных <math>\gamma_{i,j}</math>, соответствующих степени принадлежности этих объектов кластеру <math>j</math>, согласно формулам шага M [[#Математическое описание алгоритма|раздела 1.2]] вычисляется нормировочный коэффициент <math>N_{j}</math> и параметры этого кластера: вес <math>w_{j}^{new}</math>, матрица ковариации <math>\Sigma_{j}^{new}</math> и центр кластера <math>\mu_{j}^{new}</math>.

[[file:EM_Maximization_step.png|thumb|center|400px|Рисунок 4: M-шаг EM алгоритма для одного кластера]]

На рисунке 5 представлена схема вычислений M-шага алгоритма для всех кластеров. <math>M_{j}, j=1..k</math> соответствует макрооперации - M-шагу для соответствующего кластера и скрытых переменных.

[[file:EM_Maximization_step_all.png|thumb|center|400px|Рисунок 5: M-шаг EM алгоритма для всех кластеров]]

== Ресурс параллелизма алгоритма ==
Из схем вычислений шагов E и M шагов алгоритма, приведенным в [[#Информационный граф|предыдущем разделе]], видно, что если размерность матрицы ковариации небольшая (тогда вычисление определителя и обратной матрицы матрице ковариации не является трудоемкой операцией), обе макрооперации EM алгоритма можно распараллеливать как по кластерам, так и по объектам.

Как правило количество кластеров, на которые нужно разбить объекты, несравнимо меньше количества объектов, поэтому распараллеливание в большинстве существующих реализаций происходит по объектам: обработка объектов по возможности равномерно распределяются по кластерам. Теоретически (если считать передачу данных между процессорами мгновенной) при наличии неограниченного числа процессоров сложность алгоритма составит <math>O(m^2 * k)</math>.

== Входные и выходные данные алгоритма ==
'''Входные данные''':
* Целое неотрицательное число <math>k</math> - количество кластеров;
* Значения координат объектов <math>x_{i}</math> - <math>n</math> объектов с <math>m</math> координатами каждый.

'''Объем входных данных''':
* <math>n * m</math> вещественных чисел (если координаты объектов - вещественные числа), <math>1</math> целое неотрицательное число.

'''Выходные данные''':
* Вектор длины <math>n</math> - для каждого объекта указан номер кластера, к которому он отнесен.

'''Объем выходных данных''':
* <math>n</math> целых неотрицательных чисел.
== Свойства алгоритма ==
=== Преимущества и недостатки<ref>EM алгоритм, его модификации и обобщения. machinelearning.ru [http://www.machinelearning.ru/wiki/index.php?title=EM-%D0%B0%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC]</ref> ===
EM-алгоритм обладает следующими преимуществами и недостатками:

'''Преимущества:'''

# Слабо чувствителен к выбросам
# Прост в реализации
# Быстро сходится при удачном выборе начальных значений параметров.

'''Недостатки:'''

# Неустойчив к выбору начальных значений параметров - от них зависит как скорость сходимости, так и результат работы: алгоритм может сойтись к локальному экстремуму функции правдоподобия, который может быть существенно ниже глобального.
# Алгоритм не находит оптимальное количество кластеров. Количество кластеров, на которые нужно разбить множество объектов, является параметром алгоритма.
# При большой размерности пространства объектов выдвинутое предположение о модели их распределения может быть некорректным.

=== Влияние структуры матрицы ковариации на форму кластера ===

[[file:DifferentCovariance.png|thumb|center|800px|Рисунок 6: Влияние структуры матрицы ковариации на форму кластеров для двумерного случая. a) - матрицы ковариации являются диагональными, b) - матрицы ковариации произвольны. <ref>Mathworks: Clustering Using Gaussian Mixture Models [http://www.mathworks.com/help/stats/clustering-using-gaussian-mixture-models.html]</ref>]]

Рисунок 6 наглядно показывает, что при диагональной форме матриц ковариации полуоси эллипса (в общем случае - эллипсоида), соответствующего распределению объектов, отнесенных кластеру, параллельны осям координат объектов. В противном случае полуоси могут располагаться произвольным образом.

=== Общие свойства ===
[[глоссарий#Вычислительная мощность|''Вычислительная мощность'']] EM алгоритма равна <math>m * k * it</math>, где <math>m</math> - размерность объекта, <math>k</math> - количество кластеров, а <math>it</math> - количество итераций.

EM-алгоритм является итерационным, и число итераций в общем случае не фиксировано: оно зависит от условий остановки, начальных приближений и расположения объектов. Поэтому этот алгоритм ''недетерминированный''. По тем же причинам EM-алгоритм является ''неустойчивым''.

= Программная реализация алгоритма =

== Особенности реализации последовательного алгоритма ==
=== Инициализация параметров распределений ===
Наиболее распространены 3 способа инициализации центров распределений для EM алгоритма:
# центр распределения совпадает со случайно выбранным объектом <math>x_{i}</math>
# все наблюдения распределяются по кластерам случайным образом, а затем для каждого кластера пересчитывается цент соответствующего распределения
# центры кластеров получаются в результате работы алгоритма k-means. Использование такой инициализации оправдано тем, что k-means требует меньших вычислительных затрат и быстрее сходится<ref>EM алгоритм (пример) machinelearning.ru [http://www.machinelearning.ru/wiki/index.php?title=EM_%D0%B0%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_(%D0%BF%D1%80%D0%B8%D0%BC%D0%B5%D1%80])</ref>

== Локальность данных и вычислений ==

== Возможные способы и особенности параллельной реализации алгоритма ==

== Масштабируемость алгоритма и его реализации ==

Многие статьи<ref name=FREERIDE>Leonid Glimcher, Gagan Agrawal. Parallelising EM Algorithm on a Cluster of SMPs [http://web.cse.ohio-state.edu/~agrawal/allpapers/europar04.pdf]</ref><ref name=CV>López-de-Teruel P. E., García J. M., Acacio; The Parallel EM Algorithm and its Applications in Computer Vision [http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.4.8470&rep=rep1&type=pdf]</ref><ref name=MULTITHREAD>Sharon X. Lee, Kaleb L. Leemaqz, Geoffrey J. McLachlan. A simple multithreaded implementation of the EM algorithm for mixture models [https://arxiv.org/pdf/1606.02054.pdf]</ref><ref name=CUDA>Araújo, G.F., H.T. Macedo, M.T. Chella, C.A.E. Montesco and M.V.O. Medeiros. PARALLEL IMPLEMENTATION OF EXPECTATION-MAXIMISATION ALGORITHM FOR THE TRAINING OF GAUSSIAN MIXTURE MODELS [https://ri.ufs.br/bitstream/123456789/1764/1/ExpectationMaximisationAlgorithm.pdf]</ref>, в которых представлены параллельные реализации EM алгоритма, описывают помимо использующихся программных и аппаратных решений результаты проведенных экспериментов с данными. В качестве примера в этом разделе будут рассмотрены результаты эксперементов, проведенных со связующим программным обеспечением (''middleware'') FREERIDE<ref>Leonid Glimchera, Ruoming Jinb, Gagan Agrawala. Middleware for data mining applications on clusters and grids [http://www.cs.kent.edu/~jin/Papers/JPDC08.pdf]</ref> (FRamework for Rapid Implementation of Datamining Engines), обеспечивающим возможность распараллеливания как для систем с общей памятью (в частности, симметричных мультипроцессорных систем), так и для систем с распределенной памятью.

Эксперименты проводились на кластере машин Pentium 700MHz связанных при помощи Myrinet<ref>https://en.wikipedia.org/wiki/Myrinet</ref> LANai 7.0 на трех наборах данных:

'''а)''' 3.3 * 10^6 объектов

'''b)''' 6.2 * 10^6 объектов

'''c)''' 12.5 * 10^6 объектов

Объекты представляют собой координаты точек 10-мерного пространства.

Количество машин в кластере варьировалось от 1 до 8, при этом на каждой машине запускалось до четырех параллельных потоков.

Результаты экспериментов представлены на рисунках 7-9<ref name=FREERIDE/>:

{|align="center"
|-valign="top"
|[[file:EM_FREERIDE_experiments_a.png|thumb|center|350px|Рисунок 7: набор данных a)]]
|[[file:EM_FREERIDE_experiments_b.png|thumb|center|357px|Рисунок 8: набор данных b)]]
|[[file:EM_FREERIDE_experiments_c.png|thumb|center|351px|Рисунок 9: набор данных c)]]
|}

Несмотря на то, что используемые в данном исследовании машины, как и коммуникационная среда, сейчас не используются и считаются устаревшими, результат приведенных экспериментов наглядно показывает, что EM алгоритм хорошо параллелится, зависимость ускорения от числа узлов в кластере с небольшим количеством узлов близка к линейной, а также, что скорость работы алгоритма линейно зависит от числа объектов.

'''''Данный раздел может быть дополнен'''''

== Динамические характеристики и эффективность реализации алгоритма ==

== Выводы для классов архитектур ==

== Существующие реализации алгоритма ==
Примеры библиотек, содержащих последовательную реализацию EM-алгоритма, или отдельных реализаций:

# [http://docs.opencv.org/2.4/modules/ml/doc/expectation_maximization.html OpenCV(C++)] ([https://github.com/opencv/opencv/blob/master/modules/ml/src/em.cpp github])
# [http://www.mathworks.com/help/stats/clustering-using-gaussian-mixture-models.html Matlab]
# [http://scikit-learn.org/stable/modules/mixture.html Scikit learn (Python)]
# [http://mlpack.org/index.html MLPack(C++)]

Примеры библиотек, содержащих параллельную реализацию EM-алгоритма, или отдельных реализаций:

''Здесь приводятся как конкретные реализации, так и статьи, описывающие подходы к реализациям распараллеливания EM-алгоритма''

# [https://spark.apache.org/ Apache Spark]
# [http://accord-framework.net/ Accord.NET Framework (C#)]
# Статья об использовании FREERIDE middleware для распараллеливания EM алгоритма <ref name=FREERIDE/>
# [http://andrewharp.com/gmmcuda реализация с использованием CUDA]
# [https://github.com/Corv/CUDA-GMM-MPI еще одна реализация с использованием CUDA]
# статья об использовании параллельного EM алгоритма в задачах компьютерного зрения <ref name=CV/>
# статья о распараллеливании EM алгоритма с использованием CUDA <ref name=CUDA/>

= Литература =
<references />

Участник:Мария Готман/Алгоритм кластеризации, основанный на максимизации ожидания

2016-10-31T14:01:46Z

Algoman:

Авторы описания: [[Участник:Мария_Готман|Готман М.Л.]], [[Участник:Julia_lukashkina|Лукашкина Ю.Н.]]

= ЧАСТЬ. Свойства и структура алгоритмов =
== Общее описание алгоритма ==
Задача кластеризации — это задача разбиения заданной входной выборки объектов на непересекающиеся подмножества, называемые кластерами, так, чтобы каждый кластер состоял из схожих объектов, а объекты разных кластеров существенно отличались.

Для решения этой задачи можно использовать, например, метод максимизации ожидания, также известный как EM-алгоритм (англ. expectation-maximization) <ref>Воронцов К.В.; Математические методы обучения по прецедентам (теория обучения машин)</ref>. В таком случае делается предположение, что входные данные — смесь многомерных нормальных распределений, соотвественно отдельный кластер — это одна компонента смеси. Предполагается, что количество кластеров является входным параметром алгоритма (существуют модификации EM-алгоритма, которые автоматически находят число кластеров, но они не рассматриваются в данной статье). Результат работы EM-алгоритма — веса кластеров и найденные параметры нормальных распределений для каждого кластера: вектора математических ожиданий и матрицы ковариации.

Алгоритм EM кластеризации основан на итеративном выполнении двух последовательных шагов: E-шага и M-шага. На E-шаге вычисляеются вспомогательные (скрытые) переменные, которые характеризуют апостериорную вероятность того, что определенный обучающий объект получен из фиксированной компоненты смеси. На M-шаге с помощью вычесленных скрытых переменных производится обновление параметров смеси: по определённым формулам пересчитываются веса кластеров, их математические ожидания и матрицы ковариаций.

Стоит отметить, что на работу EM-алгоритма значительно влияет начальное приближение его параметров. При неудачной инициализации алгоритм может не сойтись или сойтись в локальный экстремум.

В данной статье рассматривается частный случай EM-алгоритма, который работает с двумерными входными данными.

[[Файл:Em clusters 4.png|400px|thumb|center|Пример работы EM-алгоритма для 5ти кластеров.]]

== Математическое описание алгоритма ==
Рассматривается смесь нормальных распределений <math>p(x)=\sum_{j=1}^kw_jp_j(x), \sum_{j=1}^kw_j =1, w_j \ge 0</math>.

Алгоритм кластеризации, основанный на максимизации правдоподобия, итеративно выполняет два шага: E-шаг и M-шаг.
Идея алгоритма заключается в введении матрицы скрытых переменных <math>G</math>, где <math>g_{ij} \equiv P(\theta_j |x_i)</math> обозначает вероятность принадлежности <math>i</math>-го объекта <math>j</math>-му кластеру.

На Е-шаге вычисляется ожидаемое значение скрытых переменных, на М-шаге выполняется максимизация логарифма полного правдоподобия, результатом которой являются новые значения параметров модели.

На вход алгоритму подается матрица объектов-признаков <math>X \in \R^{m \times d}</math> и <math>k</math> — количество кластеров.

На выходе получаем набор параметров модели для каждого кластера <math>\Theta = (w_1,...,w_k;\;\mu_1,...,\mu_k;\;\Sigma_1,...,\Sigma_k)</math>, где <math>w_j</math> — вес <math>j</math>-го кластера в смеси нормальных распределений, <math>\mu_j</math> — математическое ожидание <math>j</math>-ой компоненты смеси, <math>\Sigma_j</math> — матрица ковариации <math>j</math>-ой компоненты смеси.

E-шаг:

<math>g_{ij} = \frac{w_jN(x_i;\mu_j, \Sigma_j)}{\sum_{s=1}^k w_sN(x_i;\mu_s, \Sigma_s)}</math>

M-шаг:

<math>Q(\Theta) = \ln\prod_{i=1}^mp(x_i) = \sum_{i=1}^m\ln\sum_{j=1}^kw_jp_j(x_i) \rightarrow \max_{\Theta}</math>, при условии <math>\sum_{j=1}^kw_j=1</math>, где

<math>p_j(x_i) = N(x_i;\mu_j, \Sigma_j) = \frac1{(2\pi)^{d/2}\sqrt{|\Sigma_j|}} \exp \biggl(-\frac{1}{2}(x_i - \mu_j) \Sigma_j^{-1} (x_i - \mu_j)^T\biggr) </math>

Решением оптимизационной задачи являются формулы для пересчета параметров:

<math>w_j = \frac1m\sum_{i=1}^m g_{ij}</math>,

<math>\mu_j = \frac1{mw_j}\sum_{i=1}^m g_{ij}x_i</math>,

<math>\Sigma_j = \frac1{mw_j}\sum_{i=1}^m g_{ij}(x_i - \mu_j)(x_i - \mu_j)^T,\; j = 1, \dots, k</math>

== Вычислительное ядро алгоритма ==
Вычислительное ядро алгоритма представляет собой итерационное вычисление всех параметров модели, независимое по <math>m</math> объектам выборки <math>X</math>.
На каждой итерации алгоритма на Е-шаге пересчитывается значение скрытых переменных, на M-шаге пересчет параметров модели с учетом скрытых переменных.

== Макроструктура алгоритма ==
Как записано в [[#Вычислительное ядро алгоритма|описании ядра алгоритма]], основную часть метода составляют вычисления элементов матрицы G на E шаге, и пересчет параметров <math>\Theta</math> на M-шаге.

== Схема реализации последовательного алгоритма ==
# Инициализация параметров
# for iter = 1 : max_iterations
# [E-шаг]
## вычисление <math>\Sigma_j^{-1}</math> и <math>\frac1{(2\pi)^{d/2}\sqrt{|\Sigma_j|}}, j = 1 : k</math>
## вычисление <math>g_{ij},\;i = 1 : m, \; j = 1 : k</math>
## вычисление <math>LL_i</math> (логарифм правдоподобия), <math>\;i = 1 : m</math>
# [M-шаг]
## вычисление <math>\tilde w_j = \sum_{i=1}^m g_{ij}, \; j = 1 : m</math>
## вычисление <math>\tilde \mu_j = \sum_{i=1}^m g_{ij}x_i,\; j = 1 : k</math>
## вычисление <math>\tilde \Sigma_j = \sum_{i=1}^m g_{ij}(x_i - \mu_j)^T(x_i - \mu_j),\; j = 1 : k</math>
## нормировка <math>w_j = \frac{\tilde w_j}{m}</math>, <math>\mu_j = \frac{\tilde \mu_j}{w_j}, \tilde \Sigma_j = \frac{\tilde \Sigma_j}{w_j}, \;j = 1 : k</math>
# вычисление изменения логарифма правдоподобия<math>\Delta LL</math>
# if (<math>\Delta LL < \varepsilon</math>) then break;
# end for

== Последовательная сложность алгоритма ==
E-шаг:
# вычисление обратной матрицы <math>\Sigma_j^{-1}, j = 1 : k</math> при фиксированном <math>j</math> для двумерного случая по явным формулам имеет сложность <math>O(d^2)</math>, для всех кластеров — <math>O(d^2k)</math>
# вычисление <math>g_{ij}, i = 1 : m, j = 1 : k</math> при фиксированных <math>i, j</math> имеет сложность <math>O(d)</math>, сложность вычисления матрицы G — <math>O(dmk)</math>
# вычисление <math>LL_i, i = 1 : m</math> при фиксированном <math>i</math> имеет сложность <math>O(k)</math>, для всех объектов имеет сложность <math>O(mk)</math>,
M-шаг:
# вычисление <math>w_j, j = 1 : k</math> при фиксированном <math>j</math> имеет сложность <math>O(m)</math>, для весов всех кластеров — <math>O(mk)</math>
# вычисление <math>\mu_j, j = 1 : k</math> при фиксированном <math>j</math> имеет сложность <math>O(dm)</math>, для всех кластеров — <math>O(dmk)</math>
# вычисление <math>\Sigma_j, j = 1 : k</math> при фиксированном <math>j</math> имеет сложность <math>O(d^2m)</math>, для всех кластеров — <math>O(d^2mk)</math>
# нормировка <math>w</math>, <math>\mu_j = \frac{\mu_j}{w_j}, \Sigma_j = \frac{\Sigma_j}{w_j}, j = 1 : k</math> имеет сложность <math>O(k)</math>, <math>O(dk)</math>, <math>O(d^2k)</math>
# вычисление изменения логарифма правдоподобия<math>\Delta LL</math> имеет сложность <math>O(1)</math>

Сложность алгоритма на одной итерации:

<math>O(k(d^2+dm+m+m+dm+d^2m+1+d+d^2)) = O(d^2mk)</math>, так как мы рассматриваем задачу для двумерного случая, то есть <math>d=2</math>, множитель <math>d^2</math> можно отнести в константу, итоговая сложность вычисления на одной итерации <math>O(mk)</math>.

Для <math>n</math> итераций итоговая сложность алгоритма будет равна:

<math>O(mkn)</math>, где <math>m</math> — число объектов, <math>k</math> — число кластеров, <math>n</math> — число итераций.

== Информационный граф ==

Опишем граф алгоритма для следующих входных данных: <math>m = 3,\; k = 2,\; d = 2</math>, то есть 3 входных объекта и 2 кластера.

На рис.1 показана макроструктура EM-алгоритма. Входными данными в таком случае являются матрица <math>X \in \R^{3 \times 2}</math> и число кластеров <math>k = 2</math>.
На шаге <math>\mathbf{init}</math> происходит инициализация начальных приближений параметров модели и затем итеративное повторение <math>\mathbf{E}</math> и <math>\mathbf{M}</math> шагов алгоритма.

[[file:EM.png|thumb|center|300px|Рис.1. Граф EM-алгоритма с отображением входных и выходных данных]]

E-шаг. На рис.2 детально изображена схема E-шага.
Входные параметры <math>x_1,\; x_2,\; x_3 \in \R^{1 \times 2}</math> являются строчками входной матрицы <math>X</math>, также на вход подаются текущие приближения векторов средних значений (<math>\mu_1, \;\mu_2</math>), матриц ковариаций (<math>\Sigma_1, \Sigma_2</math>) и весов <math>w</math>.

Вершинами <math>\mathbf{eI}</math> обозначена операция нахождения обратной матрицы <math>\Sigma_j^{-1},\; j = 1,2</math>. Вершины группы <math>\mathbf{eS}</math> обозначают вычитание векторов <math>x_i - \mu_j,\; i = 1,2,3; \; j = 1, 2</math>. Салатовые узлы графа <math>\mathbf{eE}</math> обозначают вычисление ненормированного значения <math>g_{ij}, \;i = 1,2,3;\;j=1,2</math> по формулам из раздела [[#Схема реализации последовательного алгоритма|описания алгоритма]]. Далее выход вершин этой группы подаётся на вход вершинам <math>\mathbf{eN}</math>, которые обозначают нормировку, затем в <math>\mathbf{eL}</math> происходит подсчет логарифма правдоподобия. На выходе этого графа получаются скрытые переменные <math>g_{ij}</math> и логарифм правдоподобия LL.

[[file:EM_E_step.png|thumb|center|500px|Рис.2. Граф E-шага с отображением входных и выходных данных]]

M-шаг. На рисунке 3 изображена схема M-шага.
Входными параметрами являются: исходные объекты <math>x_1,\; x_2,\; x_3 \in \R^{1 \times 2}</math>, скрытые переменные <math>g_{11},\;g_{21},\;g_{31},\;\mu_1</math> для пересчета параметров первого кластера и <math>g_{12},\;g_{22},\;g_{32},\;\mu_2</math> — для второго.

Вершина <math>\mathbf{m}\boldsymbol{\mu}</math> обозначает подсчет слагаемого математического ожидания для одного объекта, затем на шаге <math>\mathbf{mS_1}</math> происходит суммирование слагаемых, и, наконец, на шаге <math>\mathbf{mN_1}</math> нормировка математического ожидания, выходом являются <math>\mu_1,\;\mu_2</math>.
Вершина <math>\mathbf{m}\boldsymbol{\Sigma}</math> обозначает подсчет слагаемого матрицы ковариации для одного объекта, затем на шаге <math>\mathbf{mS_2}</math> происходит суммирование слагаемых, и, наконец, на шаге <math>\mathbf{mN_2}</math> нормировка матрицы ковариации, выходом являются <math>\Sigma_1,\;\Sigma_2</math>.
Операция <math>\mathbf{mS_3}</math> обозначает вычисление ненормированного веса для одного шага, затем при выполнении <math>\mathbf{mN_3}</math> происходит нормировка весов, выходом являются <math>w_1,\;w_2</math>.

[[file:EM_M_step.png|thumb|center|500px|Рис.3. Граф M-шага с отображением входных и выходных данных]]

На рис.1 показана структура ЕM-алгоритма для кластеризации, на рис.2 — структура E-шага и на рис.3 — структура M-шага.

== Ресурс параллелизма алгоритма ==
Как видно из информационного графа, возможно распараллеливание как по кластерам, так и по объектам. Однако, в реальных задачах число кластеров много меньше числа объектов, поэтому распараллеливание по кластерам нецелесообразно.

В данной статье рассматривается вариант распараллеливания по объектам. Стоит отметить, что важно корректно организовать работу с параметрами модели (матрицами ковариаций, средними значениями и весами), чтобы не произошло ситуации гонки за ресурсами <ref>Воеводин В.В., Воеводин Вл.В. Параллельные вычисления. - СПб.: БХВ-Петербург, 2002. - 608 с.</ref>.

== Входные и выходные данные алгоритма ==

'''Входные данные''': плотная вещественная матрица объекты-признаки <math>X \in \R^{m \times d}</math>, количество кластеров <math>k</math>

'''Объём входных данных''': <math>m \times d + 1</math>

'''Выходные данные''': вектор весов <math>w \in \R^{k \times 1}</math>, <math>\;\;k</math> векторов <math>\mu_j \in \R^{d \times 1}</math>, <math>\;\;k</math> матриц <math>\Sigma \in \R^{d \times d}</math>

'''Объём выходных данных''': <math>k \times (d \times d + d + 1)</math>

Стоит заметить, что модель смеси распеределения полностью восстанавливается по выходным данным, и задача предсказания метки кластера для входных объектов является тривиальной.

== Свойства алгоритма ==

[[глоссарий#Вычислительная мощность|''Вычислительная мощность'']] алгоритма равна отношению числа операций к суммарному объему входных и выходных данных. Она показывает, сколько операций приходится на единицу переданных данных. Несмотря на простоту данного понятия, это значение исключительно полезно на практике: чем выше вычислительная мощность, тем меньше накладных расходов вызывает перемещение данных для их обработки, например, на сопроцессоре, ускорителе или другом узле кластера. Например, вычислительная мощность скалярного произведения двух векторов равна всего лишь <math>1</math>, а вычислительная мощность алгоритма умножения двух квадратных матриц равна <math>2n/3</math>.

EM-алгоритм не является устойчивым, результат его работы сильно зависит от начальных приближений параметров. При неудачном выборе начальных приближений алгоритм может не сойтись или сойтись в локальный экстремум.

Также, алгоритм не является детерминированным. Так как в начале работы алгоритма происходит инициализация начальных параметров случайным образом (с учетом положительной определенности и симметричности матрицы ковариации), он не может быть детерминирован.

Алгоритм сбалансирован по E и M шагам, затраты на выполнение этих этапов примерно одинаковы.

= ЧАСТЬ. Программная реализация алгоритма =

== Особенности реализации последовательного алгоритма ==
В данном разделе приведем код реализации последовательного алгоритма.

<source lang="c++">
double_vector em_algo::expectation_step(double_matrix& features)
{
long n_objects = features.size1();
int n_clusters = parameters.sigmas.size();
double pi = boost::math::constants::pi<double>();

// precalculate inverse matrices and dets
std::vector<double_matrix> sigmas_inverted(n_clusters);
std::vector<double> norm_distribution_denominator(n_clusters);
for (int i = 0; i < n_clusters; ++i)
{
double_matrix sigma_inverted(parameters.sigmas[i].size1(), parameters.sigmas[i].size2());
double det = InvertMatrix(parameters.sigmas[i], sigma_inverted);
if (det == 0)
{
std::cerr << "Matrix can not be inverted\n";
exit(1);
}
norm_distribution_denominator[i] = sqrt(pow(2 * pi, parameters.n_features) * det);
sigmas_inverted[i] = sigma_inverted;
}

hidden_vars = double_matrix(n_objects, n_clusters);
double_vector log_likelihood(n_objects, 0);

for (auto i = 0; i < n_objects; ++i)
{
double_matrix_row x(features, i);
double norm_value = 0;
for (auto j = 0; j < n_clusters; ++j)
{
double_matrix_column current_means(parameters.means, j);
double_vector x_centered = x - current_means;

double exp_power = -0.5 * inner_prod(prod(x_centered, sigmas_inverted[j]), x_centered);
hidden_vars(i, j) = parameters.weights(j) * exp(exp_power) / norm_distribution_denominator[j];

norm_value += hidden_vars(i, j);
}
double_matrix_row hidden_vars_row(hidden_vars, i);
if (norm_value != 0)
{
hidden_vars_row = hidden_vars_row / norm_value;
log_likelihood(i) = log(inner_prod(hidden_vars_row, parameters.weights));
}

}
return log_likelihood;
}

void em_algo::maximization_step(double_matrix& features)
{
int n_objects = features.size1();

double_vector w = double_vector(n_clusters, 0.0);
double_matrix means = double_matrix(parameters.n_features, n_clusters, 0.0);
std::vector<double_matrix> sigmas;
for (int j = 0; j < n_clusters; ++j)
sigmas.push_back(double_matrix(parameters.n_features, parameters.n_features, 0.0));

for (int i = 0; i < n_objects; ++i)
{
double_matrix_row x_i = row(features, i);

for (int j = 0; j < n_clusters; ++j)
{
double g = hidden_vars(i, j);
w(j) += g;

double_matrix_column single_mean = column(means, j);

single_mean += g * x_i;

double_vector x_centered = x_i - column(parameters.means, j);
for (int k = 0; k < parameters.n_features; ++k)
for (int l = 0; l < parameters.n_features; ++l)
sigmas[j](k, l) = sigmas[j](k, l) + g * x_centered(k) * x_centered(l);
}
}
// update weights
parameters.weights = w / n_objects;

for (int j = 0; j < n_clusters; ++j) {
double weight = w(j);
// update means
double_matrix_column means_old = column(parameters.means, j);
double_matrix_column means_new = column(means, j);
means_old = means_new / weight;

// update sigmas
parameters.sigmas[j] = sigmas[j] / weight;
for (int k = 0; k < parameters.n_features; ++k)
parameters.sigmas[j](k, k) = parameters.sigmas[j](k, k) + tol;
}
}

bool em_algo::is_likelihood_stabilized(double_vector likelihood, double_vector previous_likelihood)
{
double likelihood_diff = sum(likelihood) - sum(previous_likelihood);
return fabs(likelihood_diff) < tol;
}

model em_algo::process(double_matrix& features, int max_iterations)
{
int iteration = 0;
double_vector likelihood, previous_likelihood;
while (iteration++ < max_iterations && (iteration <= 2 || !is_likelihood_stabilized(likelihood, previous_likelihood)))
{
previous_likelihood = likelihood;
likelihood = expectation_step(features);
maximization_step(features);
}
return parameters;
}
</source>

Возможной реализацией является перестановка местами циклов по объектам и по кластерам на E и М шаге. В данном случае внешний цикл проходит по объектам, так как подразумевается дальнейшая реализации распараллеливания по объектам. При реализации только последовательного алгоритма более понятной версией будет реализация внешнего цикла по кластерам, и внутреннего по объектам, но такая реализация увеличит число обращений в память и общее время работы алгоритма.

== Локальность данных и вычислений ==

== Возможные способы и особенности параллельной реализации алгоритма ==

== Масштабируемость алгоритма и его реализации ==
===Масштабируемость реализации алгоритма===
Для проведения экспериментов по масштабируемости были выбраны следующие параметры алгоритма: были зафиксированы число кластеров <math>k = 4 </math>, и, также, было зафиксировано ядро рандомизации, чтобы избавиться от случайности различного выбора начального приближения параметров. Для показательности результатов условие дострочного завершения работы алгоритма в случае стабилизирования логарифма правдоподобия игнорировалось, и для каждого запуска проводилось 50 итераций EM-алгоритма.

Для экспериментов было сгенерировано 20 выборок разного размера: от 40000 объектов до 200000 с шагом в 10000. Для каждой выборки время работы алгоритма усреднялось по нескольким запускам, чтобы избежать выбросов.

Для работы с многопоточностью использовалась библиотека OpenMP. С помощью нее были распараллелены основные циклы по объектам на E и M шаге.

Эксперименты проводились на компьютере с процессором Intel(R) Core(TM) i7-5820K @ 3.30GHz, который поддерживает до 12ти потоков.

Как видно на рис. 4, производительность растет до 12 процессов, после чего время работы алгоритма снова начинает увеличиваться, то есть использование более 12 процессов при рассматриваемой конфигурации процессора не имеет смысла. Заметим также, что в увеличением числа точек, скорость работы программы линейно увеличивается.

[[file:EM performance.png|thumb|center|700px|Рис. 4 Время работы EM алгоритма в зависимости от числа процессов и размера задачи]]

В результате проведённых экспериментов был получен следующий диапазон эффективности реализации алгоритма:

* минимальная эффективность реализации 0,00072%;
* максимальная эффективность реализации 25.5037%.

[[file:EM_Efficiency.png|thumb|center|700px|Рис. 4 Эффективность EM алгоритма в зависимости от числа процессов и размера задачи]]

== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Существуют следующие последовательные реализации EM-алгоритма для кластеризации: [http://docs.opencv.org/2.4/modules/ml/doc/expectation_maximization.html# opencv], [http://scikit-learn.org/stable/modules/mixture.html scikit-learn].

Также существует несколько параллельных реализаций, описанных в следующих статьях:

В статье <ref>López-de-Teruel P. E., García J. M., Acacio; The Parallel EM Algorithm and its Applications in Computer Vision</ref> авторы предлагают распределить вычисление скрытых переменных для каждого объекта между процессорами и на каждой итерации производить нормализацию. M-шаг предлагается параллелить по компонентам, что требует реализации корректного взаимодействия между процессорами. Предложенный вариант распараллеливания был реализован и протестирован авторами статьи с помощью MPI библиотеки MPICH.

Авторы статьи <ref>Abhinandan Das, Mayur Datar, Ashutosh Garg; Google News Personalization: Scalable Online Collaborative Filtering
[[en:Description of algorithm properties and structure]]</ref> используют MapReduce для распараллеливания EM-алгоритма для PLSI моделей.

= Литература =

<references \>

Обсуждение участника:Мария Готман

2016-10-31T14:01:09Z

Algoman:

== Замечания к [[Алгоритм_кластеризации,_основанный_на_максимизации_ожидания]] ==

1) список литературы лучше оформить средствами разметки - см. как сделано в [[Разложение_Холецкого_(метод_квадратного_корня)]]

Список литературы исправлен.

== Замечения от 31.10 ==

"- В конце статьи должен быть приведен список всех источников, откуда бралась информация по алгоритму. Если вы используется готовый рисунок, то сслыку на источник нужно разместить либо в подписи к рисунку, либо в тексте, где стоит ссылка на рисунок."

какой источник картинок с графиками? созданы ли они авторами для этой статьи, публиковались ли где-то ещё?

Участник:Sergey Lavrushkin/EM-алгоритм кластеризации

2016-10-31T13:57:04Z

Algoman:

{{Assignment|Algoman}}

{{algorithm
| name = EM-алгоритм кластеризации (1 итерация)
| serial_complexity = <math>O(nkq^2)</math>
| pf_height = <math>O(\log{n})</math>
| pf_width = <math>O(nk)</math>
| input_data = <math>nq + 1</math>
| output_data = <math>k(n + q^2 + q + 1)</math>
}}
Автор статьи: [[Участник: Sergey Lavrushkin|Сергей Лаврушкин]] (группа 620)

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===

==== EM-алгоритм ====
EM-алгоритм (англ. expectation-maximization) — алгоритм, используемый в математической статистике для нахождения оценок максимального правдоподобия параметров вероятностных моделей, в случае, когда модель зависит от некоторых скрытых переменных. Каждая итерация алгоритма состоит из двух шагов. На E-шаге (expectation) вычисляется ожидаемое значение функции правдоподобия, при этом скрытые переменные рассматриваются как наблюдаемые. На M-шаге (maximization) вычисляется оценка максимального правдоподобия, таким образом увеличивается ожидаемое правдоподобие, вычисляемое на E-шаге. Затем это значение используется для E-шага на следующей итерации. Алгоритм выполняется до сходимости.<ref>ЕМ-алгоритм, его модификации и обобщения [http://www.machinelearning.ru/wiki/index.php?title=EM-%D0%B0%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC http://www.machinelearning.ru/]</ref>

Как правило, ЕМ-алгоритм применяется для решения задач двух типов:
* К первому типу можно отнести задачи, связанные с анализом действительно неполных данных, когда некоторые статистические данные отсутствуют в силу каких-либо причин.
* Ко второму типу задач можно отнести те задачи, в которых функция правдоподобия имеет вид, не допускающий удобных аналитических методов исследования, но допускающий серьезные упрощения, если в задачу ввести дополнительные «ненаблюдаемые» (скрытые, латентные) переменные. Примерами прикладных задач второго типа являются задачи распознавания образов, реконструкции изображений. Математическую суть данных задач составляют задачи кластерного анализа, классификации и разделения смесей вероятностных распределений.

Алгоритм основан на методике итеративного вычисления оценок максимального правдоподобия, предложенной в 1977 г. (A. P. Demster, N. M. Laird, D. B. Rubin. Maximum Likelihood from Incomplete Data via the EM Algorithm).<ref> A. Dempster, N. Laird and D. Rubin. Maximum likelihood estimation from incomplete data. – Journal of the Royal Statistical Society, Series B, 1977, vol. 39, p. 1-38.</ref>

==== Кластеризация с помощью EM-алгоритма ====

Кластеризация — задача разбиения заданной выборки объектов (ситуаций) на непересекающиеся подмножества, называемые кластерами, так, чтобы каждый кластер состоял из схожих объектов, а объекты разных кластеров существенно отличались <ref>Кластеризация [http://www.machinelearning.ru/wiki/index.php?title=%D0%9A%D0%BB%D0%B0%D1%81%D1%82%D0%B5%D1%80%D0%B8%D0%B7%D0%B0%D1%86%D0%B8%D1%8F www.machinelearning.ru]</ref>. В основе идеи применения EM-алгоритма для кластеризации лежит предположение, что исследуемое множество данных может быть смоделировано с помощью линейной комбинации многомерных нормальных распределений, а целью является оценка параметров распределения, которые максимизируют логарифмическую функцию правдоподобия, используемую в качестве меры качества модели. К оцениваемым параметрам относятся математические ожидания и ковариационные матрицы. Предполагается, что любое наблюдение принадлежит ко всем кластерам, но с разной вероятностью. Задача заключается в "подгонке" распределений смеси к данным, а затем в определении вероятностей принадлежности наблюдения к каждому кластеру. Наблюдение должно быть отнесено к тому кластеру, для которого данная вероятность выше.

Алгоритм EM основан на вычислении расстояний. Он может рассматриваться как обобщение кластеризации на основе анализа смеси вероятностных распределений. В процессе работы алгоритма происходит итеративное улучшение решения, а остановка осуществляется в момент, когда достигается требуемый уровень точности модели. Мерой в данном случае является монотонно увеличивающаяся статистическая величина, называемая логарифмическим правдоподобием.<ref>EМ — масштабируемый алгоритм кластеризации [https://basegroup.ru/community/articles/em basegroup.ru]</ref>

=== Математическое описание алгоритма ===
Исходные данные:
* <math>k</math> — число кластеров,
* <math>X =\{x_{1}, x_{2}, ..., x_{n}\}</math> — множество из <math>n</math> наблюдений <math>q</math>-мерного пространства.
Вычисляемые данные:
* <math>(w, \theta) = (w_1, ..., w_k; \mu_1, ..., \mu_k; \Sigma_1, ..., \Sigma_k)</math> — параметры смеси гауссовых распределений,
* <math>Y</math> — матрица размера <math>n \times k</math> с вероятностями членства в кластерах.
==== Постановка задачи разделения смеси гауссовых распределений ====
Пусть <math>w_1, ..., w_k</math> — априорные вероятности кластеров, <math>p_1(x), ..., p_k(x)</math> — плотности распределения кластеров.
Тогда плотность распределения вектора признаков <math>x</math> сразу по всем кластерам равна:
:<math>
\begin{align}
p(x) = \sum_{j=1}^{k}w_jp_j(x)
\end{align}
</math>
Необходимо на основе выборки оценить параметры модели <math>w_1, ..., w_k, p_1(x), ..., p_k(x)</math>. Это позволит оценивать вероятность принадлежности к кластеру и, таким образом, решить задачу кластеризации. Такая задача
называется задачей разделения смеси распределений:
:<math>
\begin{align}
p(x) = \sum_{j=1}^{k}w_jp_j(x),\quad p_j(x) = \phi(\theta_j; x),
\end{align}
</math>
где <math>\theta_j</math> — параметры распределения <math>p_j(x)</math>.
В случае смести гауссовых распределений предполагается, что все компоненты имеют многомерное нормальное распределение. То есть в случае <math>q</math>-мерного пространства признаков <math>\phi(\theta_j; x)</math> имеют следующий вид:
:<math>
\begin{align}
& \phi(\theta_j; x) = \frac{1}{\Big(2\pi\Big)^{\frac{q}{2}}\sqrt{|\Sigma_j|}}\exp{\bigg\{-\frac{\delta^2}{2}\bigg\} },\\
& \delta^2 = \Big( x - \mu_j \Big)^T \Sigma_j^{-1} \Big( x - \mu_j \Big),
\end{align}
</math>
где:
* <math>\Sigma_j</math> — ковариационная матрица размером <math>q \times q</math>,
* <math>\mu_j</math> — <math>q</math>-мерный вектор математических ожиданий,
* <math>\delta^2</math> — квадратичное расстояние Махаланобиса.
В случае смеси гауссовых распределений получаем, что <math>\theta_j = (\mu_j, \Sigma_j)</math>. То есть для решения задачи разделения смеси гауссовых распределений необходимо оценить вектор параметров <math>(w, \theta) = (w_1, ..., w_k; \mu_1, ..., \mu_k; \Sigma_1, ..., \Sigma_k)</math>. Согласно принципу максимизации правдоподобия:
:<math>
\begin{align}
w, \theta = \underset{w, \theta}{\operatorname{argmax}} \sum_{i=1}^{n}\ln{p(x_i)} = \underset{w, \theta}{\operatorname{argmax}} \sum_{i=1}^{n}\ln{\sum_{j=1}^{k}w_jp_j(x_i)}
\end{align}
</math>
Таким образом, имеет место задача максимизации суммы логарифмов сумм, решение которой представляет большую трудность. В таком случае полезным оказывается итеративный метод решения — EM-алгоритм.<ref>Поиск структуры в данных — Lecture 9 — Expectation Maximization (EM-алгоритм) [https://www.coursera.org/learn/unsupervised-learning/lecture/2jhbI/expectation-maximization-em-alghoritm www.coursera.org]</ref>

==== EM-алгоритм ====
Оптимальные параметры задачи разделения смеси гауссовых распределений отыскиваются последовательно с помощью итерационного EM-алгоритма. Основная идея – вводится вспомогательный вектор скрытых переменных. Это позволяет свести сложную оптимизационную задачу к последовательности итераций по пересчету коэффициентов (скрытых переменных по текущему приближению вектора параметров - E-шаг) и максимизации правдоподобия (с целью найти следующее приближение вектора - М-шаг).<ref>EM алгоритм (пример) [http://www.machinelearning.ru/wiki/index.php?title=EM_%D0%B0%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_(%D0%BF%D1%80%D0%B8%D0%BC%D0%B5%D1%80) www.machinelearning.ru]</ref>

EM-алгоритм заключается в следующем:
<ol>
<li> В начале работы алгоритма задаются параметры начального приближения. Наиболее общим способом инициализации является присвоение элементам матрицы математических ожиданий случайных значений <math> \mu_j \leftarrow Random </math>, начальные ковариационные матрицы определяются как единчиные <math>\Sigma_j \leftarrow I</math>, веса кластеров задаются одинаковыми <math>w_i \leftarrow \frac{1}{k}</math>. Также в качестве начальных параметров можно использовать результат работы алгоритма K-means. (Данная эвристика применяется, так как K-means требуется намного меньше итераций до достижения стабилизации, в то время как каждый шаг EM требует больших вычислительных затрат).</li>
<li> Далее итеративно выполняется следующая пара процедур:
<ul>
<li>E-шаг: используя текущее значение вектора параметров <math>(w, \theta) = (w_1, ..., w_k; \mu_1, ..., \mu_k; \Sigma_1, ..., \Sigma_k)</math>, вычисляем значения скрытых переменных <math>y_{ij}</math>:
:<math>
\begin{align}
& y_{ij} = \frac{w_j p_j(x_i)}{\sum_{l=1}^{k}w_lp_l(x_i)}
\end{align}
</math></li>
<li>М-шаг: переоценка вектора параметров, используя текущие значения скрытых переменных:
:<math>
\begin{align}
& n_j = \sum_{i = 1}^{n}y_{ij}, \\
& \mu_j^{new} = \frac{1}{n_j} \sum_{i = 1}^{n}y_{ij}x_i, \\
& \Sigma_j^{new} = \frac{1}{n_j} \sum_{i = 1}^{n}y_{ij}(x_i - \mu_j^{new})(x_i - \mu_j^{new})^T,\\
& w_j^{new} = \frac{n_j}{n}.
\end{align}
</math></li>
</ul>
</li>
</ol>
Итерации происходят до сходимости (норма разности векторов скрытых переменных или изменение логарифмического правдоподобия на каждой итерации не будет превышать заданную константу) или достижения максимального числа итераций.

=== Вычислительное ядро алгоритма ===
В вычислительное ядро EM-алгоритма входят:
* Вычисление скрытых переменных <math>y_{ij}</math> на E-шаге (всего их <math>nk</math>).
* Переоценка вектора параметров <math>(w_1, ..., w_k; \mu_1, ..., \mu_k; \Sigma_1, ..., \Sigma_k)</math> на M-шаге, используя текущие значения скрытых переменных <math>y_{ij}</math>.

=== Макроструктура алгоритма ===
Как записано в описании ядра алгоритма, основную часть метода составляют множественные вычисления скрытых переменных <math>y_{ij}</math> на E-шаге и обновление вектора параметров <math>(w_1, ..., w_k; \mu_1, ..., \mu_k; \Sigma_1, ..., \Sigma_k)</math> на M-шаге.
Также стоит выделить вычисление определителя и обратной матрицы ковариационных матриц <math>\Sigma_j</math> в начале E-шага.

=== Схема реализации последовательного алгоритма ===
Последовательная реализация алгоритма EM может быть проиллюстрирована с помощью следующего псевдокода:
# '''Инициализация''': установка начальных значений <math>\mu, \, \Sigma_j \, (j = \overline{1, k}), \, w</math>.
# '''Пока''' изменение логарифмического правдоподобия <math>\Delta llh \geq \epsilon</math> и не достигнуто максимальное число итераций <math>m</math>, '''выполнять''' шаги E и M.
'''Шаг E'''

'''def''' E-step:
'''Инициализировать''' нулевыми значениями <math>\mu^{'}, \, \Sigma_j^{'} \, (j = \overline{1, k}), \, w^{'}, \, llh</math>
'''for''' <math>j = \overline{1, k}</math>:
'''Вычислить''' определитель и обратную матрицу матрицы <math>\Sigma_j</math>
'''for''' <math>i = \overline{1, n}</math>:
<math>sump_i = 0</math>
'''for''' <math>j = \overline{1, k}</math>:
<math>\delta_{ij} = \big( x_i - \mu_j \big)^T \Sigma_j^{-1} \big( x_i - \mu_j \big)</math>
<math>g_{ij} = \frac{w_j}{{2 \pi}^\frac{q}{2}|\Sigma_j|}\exp{\big\{-\frac{\delta^2}{2}\big\} }</math>
<math>sump_i \mathrel{+}= g_{ij}</math>
<math>y_i = \frac{g_i}{sump_i}</math>
<math>llh \mathrel{+}= \ln(sump_i)</math>
<math>\mu^{'} \mathrel{+}= x_iy_i^T</math>
<math>w^{'} \mathrel{+}= y_i</math>

'''Шаг M'''

'''def''' M-step:
'''for''' <math>j = \overline{1, k}</math>:
<math>\mu_j = \frac{\mu_j^{'}}{w_j^{'}}</math>
'''for''' <math>i = \overline{1, n}</math>:
<math>\Sigma_j^{'} \mathrel{+}= (x_i - \mu_j)y_{ij}(x_i - \mu_j)^T</math>
<math>\Sigma_j = \frac{\Sigma_j^{'}}{w_j^{'}}</math>
<math>w = \frac{w^{'}}{n}</math>
Логаририфмическое правдоподобие вычисляется как:
:<math>
\begin{align}
llh=\sum_{i=1}^{n}\ln{(sump_i)}
\end{align}
</math>
Матрицы <math>\mu^{'}, \, \Sigma_j^{'} \, (j = \overline{1, k}), \, w^{'}</math> являются временными и используются только для вычислений.

=== Последовательная сложность алгоритма ===
Последовательная сложность одной итерации EM-алгоритма:
<ol>
<li> E-шаг: 
В случае недиагональных ковариационных матриц сложность вычислений:
* Определителей ковариационных матриц <math>|\Sigma_j|</math> (<math>j = \overline{1, k}</math>) методом Гаусса: <math>O(kq^3)</math>,
* Матриц, обратных ковариационным матрицам <math>\Sigma_j^{-1}</math> (<math>j = \overline{1, k}</math>) методом Гаусса-Жордана: <math>O(kq^3)</math>,
* Скрытых переменных <math>y_{ij}</math> (<math>i = \overline{1, n}, j = \overline{1, k}</math>): <math>O(nkq^2)</math>.
В случае диагональных ковариационных матриц сложность вычислений:
* Определителей ковариационных матриц <math>|\Sigma_j|</math> (<math>j = \overline{1, k}</math>): <math>O(kq)</math>,
* Матриц, обратных ковариационным матрицам <math>\Sigma_j^{-1}</math> (<math>j = \overline{1, k}</math>): <math>O(kq)</math>,
* Скрытых переменных <math>y_{ij}</math> (<math>i = \overline{1, n}, j = \overline{1, k}</math>): <math>O(nkq)</math>.
Получаем, что последовательная сложность E-шага в случае недиагональных ковариационных матриц имеет порядок <math>O(kq^3 + nkq^2)</math>, а в случае диагональных ковариационных матриц — <math>O(nkq)</math>.
</li>
<li>
М-шаг: 
В случае недиагональных ковариационных матриц сложность вычислений:
* Обновление математических ожиданий <math>\mu_j</math> (<math>j = \overline{1, k}</math>): <math>O(nkq)</math>,
* Обновление ковариационных матриц <math>\Sigma_j</math> (<math>j = \overline{1, k}</math>): <math>O(nkq^2)</math>,
* Обновление весов кластеров <math>w_j</math> (<math>j = \overline{1, k}</math>): <math>O(nk)</math>.
В случае диагональных ковариационных матриц сложность вычислений:
* Обновление математических ожиданий <math>\mu_j</math> (<math>j = \overline{1, k}</math>): <math>O(nkq)</math>,
* Обновление ковариационных матриц <math>\Sigma_j</math> (<math>j = \overline{1, k}</math>): <math>O(nkq)</math>,
* Обновление весов кластеров <math>w_j</math> (<math>j = \overline{1, k}</math>): <math>O(nk)</math>.
Получаем, что последовательная сложность М-шага в случае недиагональных ковариационных матриц имеет порядок <math>O(nkq^2)</math>, а в случае диагональных ковариационных матриц — <math>O(nkq)</math>.
</li>
</ol>
Таким образом, последовательная сложность итерации EM-алгоритма в случае недиагональных ковариационных матриц имеет порядок <math>O(kq^3 + nkq^2)</math>, а в случае диагональных ковариационных матриц — <math>O(nkq)</math>. При этом, обычно размерность элементов выборки <math>q</math>, также как и число кластеров <math>k</math>, значительно меньше числа элементов выборки <math>n</math> (<math>k \ll n, q \ll n</math>), поэтому в случае недиагональных ковариационных матриц сложность может быть записана в виде <math>O(nkq^2)</math>.

=== Информационный граф ===

Граф алгоритма в терминах E-шагов и M-шагов представлен на рис. 1. Каждая итерация алгоритма зависит от результата работы предыдущей итерации, M-шаг зависит от результата E-шага.

[[Файл:EM-alg-Lavrushkin.png|thumb|1000px|center|Рисунок 1. Граф EM-алгоритма. <math>k</math> — число кластеров; <math>X</math> — множество наблюдений; <math>Y</math> — матрица с вероятностями членства в кластерах.]]

Рассмотрим по отдельности информационные графы E-шага и M-шага.

==== E-шаг ====
Опишем граф E-шага как аналитически, так и в виде рисунка.

Граф алгоритма состоит из четырех групп вершин:
*'''Первая''' группа вершин соответствует вычислению обратных матриц и определителей ковариационных матриц. Число вершин: <math>k</math>. Аргументом этой операции является ковариационная матрица <math>\Sigma_j</math>. Результат срабатывания операции является промежуточным данным алгоритма.
*'''Вторая''' группа вершин соответствует вычислению <math>g_{ij} = \frac{w_j}{{2 \pi}^\frac{q}{2}|\Sigma_j|}\exp{\big\{-\frac{1}{2} \big( x_i - \mu_j \big)^T \Sigma_j^{-1} \big( x_i - \mu_j \big) \big\}}</math>. Число вершин: <math>nk</math>. Аргументами этой операции являются вес кластера <math>w_j</math>, математическое ожидание <math>\mu_j</math>, ковариационная матрица <math>\Sigma_j</math>, элемент выборки <math>x_i</math>. Результат срабатывания операции является промежуточным данным алгоритма.
*'''Третья''' группа вершин соответствует вычислению нормировочных коэффициентов <math>\sum_{l=1}^{k}g_{ij}</math>. Число вершин: <math>n</math>. Аргументами этой операции являются значения <math>g_{ij}, \, j = \overline{1, k}</math>. Результат срабатывания операции является промежуточным данным алгоритма.
*'''Четвертая''' группа вершин соответствует вычислению скрытых переменных <math>y_{ij}</math>. Число вершин: <math>nk</math>. Аргументами этой операции являются значение <math>g_{ij}</math> и нормировочный коэффициент. Результат срабатывания операции является выходным данным алгоритма.

Описанный граф представлен на рис.2 и рис.3. Здесь вершины одной группы расположены в одной строке. Вершины-операции обозначены синим цветом, вершины-данные — оранжевым.

[[Файл:E-step-Lavrushkin.png|thumb|1000px|center|Рисунок 2. Граф E-шага.]]
[[Файл:E-step2-Lavrushkin.png|thumb|800px|center|Рисунок 3. Граф E-шага с с отображением входных и выходных данных.]]

==== M-шаг ====
Опишем граф M-шага как аналитически, так и в виде рисунка.

Граф алгоритма состоит из четырех групп вершин:
*'''Первая''' группа вершин соответствует вычислению нормировочных коэффициентов <math>n_j</math>. Число вершин: <math>k</math>. Аргументами этой операции являются скрытые переменные <math>y_{ij}, \, i = \overline{1, n}</math>. Результат срабатывания операции является промежуточным данным алгоритма.
*'''Вторая''' группа вершин соответствует вычислению математических ожиданий <math>\mu_j</math>. Число вершин: <math>k</math>. Аргументами этой операции являются множество наблюдений <math>X</math>, скрытые переменные <math>y_{ij}, \, i = \overline{1, n}</math>, нормировочный коэффициент <math>n_j</math>. Результат срабатывания операции является выходным данным алгоритма.
*'''Третья''' группа вершин соответствует вычислению ковариационных матриц <math>\Sigma_j</math>. Число вершин: <math>k</math>. Аргументами этой операции являются множество наблюдений <math>X</math>, скрытые переменные <math>y_{ij}, \, i = \overline{1, n}</math>, нормировочный коэффициент <math>n_j</math>, математическое ожидание <math>\mu_j</math>. Результат срабатывания операции является выходным данным алгоритма.
*'''Четвертая''' группа вершин соответствует вычислению весов кластеров <math>w_{j}</math>. Число вершин: <math>k</math>. Аргументом этой операции является нормировочный коэффициент <math>n_j</math>. Результат срабатывания операции является выходным данным алгоритма.

Описанный граф представлен на рис.4 и рис.5. Здесь вершины одной группы расположены в одной строке. Вершины-операции обозначены синим цветом, вершины-данные — оранжевым.

[[Файл:M-step-Lavrushkin.png|thumb|1000px|center|Рисунок 4. Граф M-шага.]]
[[Файл:M-step2-Lavrushkin.png|thumb|600px|center|Рисунок 5. Граф M-шага с отображением входных и выходных данных.]]

Графы вычисления математических ожиданий <math>\mu_j</math> и ковариационных матриц <math>\Sigma_j</math> представлены на рис. 6 и рис. 7.

[[Файл:EM-alg-mean-Lavrushkin.png|thumb|1400px|center|Рисунок 6. Граф вычисления математического ожидания <math>\mu_j</math>.]]
[[Файл:EM-alg-cov-Lavrushkin.png|thumb|1400px|center|Рисунок 7. Граф вычисления ковариационной матрицы <math>\Sigma_j</math>.]]

=== Ресурс параллелизма алгоритма ===

По графам из пункта 1.7 видно, что скрытые переменные <math>y_{ij}</math> в E-шаге, <math>y_{ij}x_i</math> в вычислении математических ожиданий <math>\mu_{j}</math> и <math>y_{ij}(x_i - \mu_j)(x_i - \mu_j)</math> в вычислении ковариационных матриц <math>\Sigma_{j}</math> в M-шаге вычисляются независимо (<math>i = \overline{1, n}, \, j = \overline{1, k}</math>). Таким образом, при условии наличия неограниченного числа процессоров эти операции можно распараллелить как по числу наблюдений, так и по числу кластеров. Однако в отсутствии неограниченного числа процессорв целесообразно проводить распараллеливание по числу наблюдений, потому что, как правило, число наблюдений значительно больше числа кластеров (<math>n \gg q</math>).

При классификации по ширине ЯПФ его сложность будет <math>O(nk)</math>. Сложность ЯПФ при классификации по высоте зависит от способа вычисления обратных матриц и определителей ковариационных матриц, а также от способа суммирования при вычислении скрытых переменных и обновлении вектора параметров. Предположим, что размерность элементов выборки <math>q</math> и число кластеров <math>k</math> значительно меньше числа элементов выборки <math>n</math> (<math>k \ll n, q \ll n</math>). Тогда вычисление обратных матриц и определителей ковариационных матриц можно не учитывать, также как и суммирование при вычислении скрытых переменных. Пусть для вычисления сумм при обновлении вектора параметров используется пирамида сдваиванием. Тогда их сложность будет равна <math>O(\log{n})</math>. Следовательно, при классификации по высоте ЯПФ его сложность будет <math>O(\log{n})</math>.

=== Входные и выходные данные алгоритма ===
'''Входные данные''': <math>k</math> — число кластеров; <math>X =\{x_{1}, x_{2}, ..., x_{n}\}</math> — множество из <math>n</math> наблюдений <math>q</math>-мерного пространства.

'''Объем входных данных''': <math>nq + 1</math>.

'''Выходные данные''': <math>(w, \theta) = (w_1, ..., w_k; \mu_1, ..., \mu_k; \Sigma_1, ..., \Sigma_k)</math> — параметры смеси гауссовых распределений; <math>Y</math> — матрица размера <math>n \times k</math> с вероятностями членства в кластерах.

'''Объем выходных данных''': <math>k(n + q^2 + q + 1)</math>.

=== Свойства алгоритма ===
Алгоритм является ''недетерминированным''. Число итераций до сходимости метода зависит от начального приближения и выбранного критерия останова.

Предположим, что размерность элементов выборки <math>q</math> и число кластеров <math>k</math> значительно меньше числа элементов выборки <math>n</math> (<math>k \ll n, q \ll n</math>), а число итераций до сходимости метода равно <math>m</math>. Тогда вычислительная мощность алгоритма, как отношение числа операций к суммарному объему входных и выходных данных, имеет порядок <math>O\bigg(\frac{kq^2}{q + k}m\bigg)</math>.
==== Достоинства и недостатки алгоритма ====
Среди достоинств EM-алгоритма можно выделить следующие:
* Мощная статистическая основа.
* Линейное увеличение сложности при росте объема данных.
* Устойчивость к шумам и пропускам в данных.
* Возможность построения желаемого числа кластеров.
* Быстрая сходимость при удачной инициализации.
К недостаткам EM-алгоритма можно отнести следующее:
* Алгоритм неустойчив по начальным данным (то есть тем, которые инициализируют вектор параметров на первой итерации), так как он находит локальный экстремум, значение которого может оказаться гораздо ниже, чем глобальный максимум. В зависимости от выбора начального приближения алгоритм может сходиться к разным точкам. Также может сильно варьироваться скорость сходимости.
* Алгоритм не позволяет определять количество <math>k</math> компонент смеси. Эта величина является структурным параметром алгоритма.
* Предположение о нормальности всех измерений данных не всегда выполняется.

== Программная реализация алгоритма ==

=== Особенности реализации последовательного алгоритма ===

=== Локальность данных и вычислений ===

=== Возможные способы и особенности параллельной реализации алгоритма ===

=== Масштабируемость алгоритма и его реализации ===

==== Масштабируемость алгоритма ====

==== Масштабируемость реализации алгоритма ====

=== Динамические характеристики и эффективность реализации алгоритма ===

=== Выводы для классов архитектур ===

=== Существующие реализации алгоритма ===
# [http://docs.opencv.org/2.4/modules/ml/doc/expectation_maximization.html OpenCV];
# [http://arma.sourceforge.net/docs.html#gmm_diag Armadillo] — OpenMP реализация с предположением диагональности ковариационных матриц;
# [http://www.mlpack.org/docs/mlpack-git/doxygen.php?doc=classmlpack_1_1gmm_1_1GMM.html MLPack];
# [http://scikit-learn.org/stable/modules/mixture.html scikit-learn];
# [http://www.mathworks.com/help/stats/clustering-using-gaussian-mixture-models.html Matlab];
# [https://github.com/Corv/CUDA-GMM-MultiGPU CUDA реализация №1];
# [http://andrewharp.com/gmmcuda CUDA реализация №2].

== Литература ==
<references \>

Участник:Александр Куваев/Алгоритм кластеризации, основанный на максимизации ожидания

2016-10-31T13:54:49Z

Algoman:

Авторы описания:
* Куваев А.С., группа 620 (математическая постановка задачи, схема реализации алгоритма, оценка сложности, описание ресурса параллелизма)
* Щенявская Е.В., группа 616 (описание алгоритма, визуализация информационного графа и примера работы алгоритма, описание свойств алгоритма)

== Свойства и структура алгоритмов ==

=== Общее описание алгоритма ===
Задача кластеризации заключается в разбиении входного множества объектов на непересекающиеся подмножества, называемые кластерами, так, чтобы каждый кластер состоял из схожих объектов, а объекты разных кластеров существенно отличались друг от друга<ref name=vorontsov>Воронцов К.В., Математические методы обучения по прецедентам.</ref>.

Решение этой задачи принципиально неоднозначно по следующим причинам<ref name=vorontsov/>:
# результат кластеризации зависит от способа задания меры сходства объектов выборки
# не существует однозначно наилучшего критерия качества кластеризации
# число кластеров, как правило, неизвестно заранее и задается из некоторых априорных соображений (хотя существуют алгоритмы, способные определять число кластеров автоматически)

По описанной выше причине существует большое число алгоритмов кластеризации, приводящих к различным разбиениям исходного множества объектов. На этой странице представлено описание одного из таких методов — EM-алгоритма. EM-алгоритм опирается на предположение о вероятностной природе данных: элементы выборки получены случайно и независимо из смеси распределений с фиксированным числом компонент <math>k</math>. Таким образом, плотность распределения на множестве объектов имеет следующий вид:

:<math>p(x)=\sum_{j=1}^{k}w_{j}p_{j}(x), \ \sum_{j=1}^{k}w_{j}=1, \ w_{j} \ge 0 </math>, где <math>p_{j}</math> - плотность распределения <math>j</math>-й компоненты смеси (кластера).

Везде в дальнейшем будем предполагать, что <math>p_{j}</math> имеют вид многомерных нормальных плотностей с произвольной матрицей ковариации: смеси нормальных распределений позволяют аппроксимировать произвольные непрерывные функции плотности с наперед заданной точностью<ref name=korolev>Королёв В.Ю., ЕМ-алгоритм, его модификации и их применение к задаче разделения смесей вероятностных распределений. Теоретический обзор. - М.: ИПИРАН, 2007.</ref>. Результатом работы EM-алгоритма являются оценки априорных вероятностей компонент смеси <math>w_{j}</math>, а также оценки векторов математических ожиданий и матриц ковариаций для каждой компоненты. Зная параметры распределения смеси, каждому объекту будет сопоставляться тот кластер, вероятность принадлежности к которому будет максимальной.

EM-алгоритм позволяет значительно упростить задачу максимизации правдоподобия выборки путем искусственного введения вспомогательной матрицы скрытых переменных <math>G</math>. Алгоритм заключается в последовательном повторении шагов E(expectation) и M(maximization):
* На шаге E на основе текущего приближения параметров смеси по формуле Байеса вычисляются ожидаемые значения скрытых переменных <math>g_{ij}</math> — апостериорные вероятности того, что <math>i</math>-й объект принадлежит кластеру <math>j</math>.
* На шаге M решается задача максимизации правдоподобия для нахождения следующего приближения параметров смеси на основе текущего приближения и матрицы скрытых переменных, при этом решение этой задачи выписывается в явном виде.

[[File:EM iterations.png|thumb|center|800px|Рисунок 1. Визуализация компонент смеси после некоторых итераций алгоритма в двумерном пространстве признаков. Для каждой компоненты эллипсами выделены доверительные области с уровнями доверия 0.9, 0.95 и 0.99.]]

=== Математическое описание алгоритма ===
Пусть заданы <math>l</math> объектов <math>x_{1},\dotsc,x_{l}</math>, каждый из которых описывается <math>n</math> числовыми признаками. Таким образом, определена матрица объектов-признаков <math>X \in \R^{l \times n}.</math> Предполагается, что объекты выбраны случайно и независимо из смеси <math>n</math>-мерных нормальных распределений с фиксированным числом компонент <math>k</math>. Плотность распределения на множестве объектов имеет вид:

:<math>p(x)=\sum_{j=1}^{k}w_{j}p_{j}(x), \ \sum_{j=1}^{k}w_{j}=1, \ w_{j} \ge 0 </math>, где <math>p_{j}</math> - плотность распределения <math>j</math>-й компоненты смеси.

Каждая компонента смеси описывается <math>n</math>-мерным вектором математических ожиданий <math>\mu_{j}</math> и матрицей ковариаций <math>\Sigma_{j}</math> порядка <math>n</math>, <math>j = 1,\dotsc,k</math>.

'''Входные данные:''' матрица объектов-признаков <math>X</math>, число кластеров <math>k</math>, максимальное число итераций <math>imax</math>, минимальная величина изменения логарифма правдоподобия <math>\varepsilon</math>.

'''Выходные данные:''' набор оценок весов, математических ожиданий и ковариационных матриц компонент смеси <math>\theta = (w_{1},...,w_{k}; \; \mu_{1},...,\mu_{k}; \; \Sigma_{1},...,\Sigma_{k})</math>, максимизирующий правдоподобие выборки.

'''Структура алгоритма:'''
* '''Инициализация параметров:''' существует большое число вариантов инициализации параметров распределения. Один из возможных подходов — задание векторов математических ожиданий компонент случайными элементами выборки, задание матриц ковариаций единичными матрицами и задание весов компонент равными <math>\frac{1}{k}.</math>
* '''Последовательное выполнение шагов E и M''' до тех пор, пока правдоподобие выборки не стабилизируется или не будет достигнуто максимальное число итераций:
** '''Шаг E:''' вычисление значений скрытых переменных по формуле Байеса:
*:<math>g_{ij} = \frac{w_{j} p_{j}(x_{i})}{\sum_{s=1}^{k} w_{s} p_{s}(x_{i})}</math> , где <math>p_{j}(x_{i}) = \frac{1}{(2\pi)^{n/2}\sqrt{|\Sigma_{j}|}} \exp \biggl( -\frac{1}{2}(x_{i} - \mu_{j})^{T} \Sigma_{j}^{-1} (x_{i} - \mu_{j}) \biggr), \ i = 1,\dotsc,l; \ j = 1,\dotsc,k </math>
** '''Шаг M:''' перерасчет параметров смеси на основе текущего приближения и матрицы скрытых переменных:
*:<math>w_{j} = \frac{1}{l} \sum_{i=1}^{l} g_{ij}, \ j = 1,\dotsc,k;</math>
*:<math>\mu_{j} = \frac{1}{l w_{j}} \sum_{i=1}^{l} g_{ij} x_{i}, \ j = 1,\dotsc,k;</math>
*:<math>\Sigma_{j} = \frac{1}{l w_{j}} \sum_{i=1}^{l} g_{ij}(x_{i} - \mu_{j})(x_{i} - \mu_{j})^T, \ j = 1,\dotsc,k.</math>

=== Вычислительное ядро алгоритма ===
Вычислительное ядро EM-алгоритма — процедура последовательного выполнения шагов E и M:
* На шаге E на основе текущего приближения параметров смеси вычисляются ожидаемые значения скрытых переменных
* На шаге M вычисляется следующее приближение параметров смеси на основе текущего приближения и матрицы скрытых переменных
Наиболее трудоемкой операцией с вычислительной точки зрения является шаг E, в ходе которого производится обращение ковариационных матриц, вычисление их определителей, а также многократное перемножение векторов и матриц при вычислении скрытых переменных.

=== Макроструктура алгоритма ===
Алгоритм состоит из двух итерационно проводимых макроопераций: E-шага и M-шага.

В ходе E-шага используется:
* Обращение ковариационной матрицы и вычисление ее определителя
* Умножение вектор-строки на матрицу и вектор-строки на вектор-столбец
В ходе M-шага используется:
* Умножение вектор-столбца на вектор-строку
* Взвешенное суммирование векторов и матриц

=== Схема реализации последовательного алгоритма ===
# Для всех <math>j = 1,\dotsc,k</math>:
#: Инициализировать <math>w_{j}, \ \mu_{j}, \ \Sigma_{j}</math>
# Для всех <math>iter = 1,\dotsc,imax</math>:
## Шаг E:
##: Для всех <math>j = 1,\dotsc,k</math>:
##:: Вычислить <math>|\Sigma_{j}|, \ \Sigma_{j}^{-1}</math>
##: Для всех <math>i = 1,\dotsc,l</math>:
##:: <math>sum = 0</math>
##:: Для всех <math>j = 1,\dotsc,k</math>:
##::: Вычислить <math>p_{j}(x_{i}) = \frac{1}{(2\pi)^{n/2}\sqrt{|\Sigma_{j}|}} \exp \biggl( -\frac{1}{2}(x_{i} - \mu_{j})^{T} \Sigma_{j}^{-1} (x_{i} - \mu_{j}) \biggr)</math>
##::: <math>sum = sum + w_{j}p_{j}(x_{i})</math>
##:: Для всех <math>j = 1,\dotsc,k</math>:
##::: Вычислить <math>g_{ij} = \frac{w_{j} p_{j}(x_{i})}{sum}</math>
## Шаг M:
##: Для всех <math>j = 1,\dotsc,k</math>:
##:: Вычислить <math>w_{j} = \frac{1}{l} \sum_{i=1}^{l} g_{ij}</math>
##:: Вычислить <math>\mu_{j} = \frac{1}{l w_{j}} \sum_{i=1}^{l} g_{ij} x_{i}</math>
##:: Вычислить <math>\Sigma_{j} = \frac{1}{l w_{j}} \sum_{i=1}^{l} g_{ij}(x_{i} - \mu_{j})(x_{i} - \mu_{j})^T</math>
## Вычислить изменения логарифма правдоподобия <math>\Delta</math>
## Если <math>\Delta < \varepsilon</math>, то досрочно выйти из цикла
# Вернуть <math>w_{j}, \mu_{j}, \Sigma_{j}, \ j = 1,\dotsc,k.</math>

=== Последовательная сложность алгоритма ===
Рассмотрим мультипликативную сложность одной итерации алгоритма:
* '''E-шаг:'''
** Сложность обращения матрицы ковариаций и вычисления ее определителя — <math>O(n^{3})</math> (для простоты будем рассматривать метод Гаусса)
** Сложность вычисления расстояния Махаланобиса (показателя экспоненты) при вычислении значения каждой скрытой переменной — <math>O(n^{2})</math>
** Общая сложность E-шага — <math>O(k * n^{3} + k * l * n^{2})</math>
* '''M-шаг:'''
** Сложность пересчета веса кластера — <math>O(l)</math>
** Сложность пересчета центра кластера — <math>O(l * n)</math>
** Сложность пересчета матрицы ковариаций кластера — <math>O(l * n)</math>
** Общая сложность M-шага — <math>O(k * l * n)</math>

Таким образом, общая сложность одной итерации — <math>O(k * n^{2} * (l + n))</math>. При учете ограничения на максимальное число итераций получим оценку общей сложности алгоритма — <math>O(imax * k * n^{2} * (l + n))</math>.

Большое влияние на сложность E-шага оказывает необходимость обращать ковариационные матрицы и вычислять их определители. Помимо того, что это трудоемкая операция, ковариационные матрицы могут оказаться плохо обусловленными, что может привести к неустойчивости выборочных оценок параметров смеси. Обращения матриц можно избежать, если принять гипотезу о том, что в каждой компоненте смеси признаки некоррелированы, то есть ковариационные матрицы диагональные. В таком случае общая сложность алгоритма составит <math>O(imax * k * n * l)</math>.

=== Информационный граф ===
На рисунках 2 и 3 представлены информационные графы<ref name=voevodin>Воеводин В.В., Воеводин Вл.В. Параллельные вычисления. - СПб.: БХВ-Петербург, 2002. - 608 с.</ref> шагов E и M соответственно. Прямоугольниками обозначены входные данные (с пометкой in/out), эллипсами обозначены операции, производимые над данными согласно алгоритму.

Как видно из рисунка 2, E-шаг распадается на:
* Обращение матриц ковариаций и вычисление их определителей
* Независимый расчет скрытых переменных по каждому объекту

[[File:E-step.png|thumb|center|1100px|Рисунок 2. Граф шага E с отображением входных и выходных данных.]]

На рисунке 3 видно, что некоторые промежуточные вычисления на шаге M можно проводить независимо для каждого объекта, но после этого придется проводить агрегацию полученных результатов по кластерам.

[[File:M-step.png|thumb|center|1100px|Рисунок 3. Граф шага M с отображением входных и выходных данных.]]

=== Ресурс параллелизма алгоритма ===
Из информационных графов на рисунках 2 и 3 видно, что:
* Шаг E — наиболее ресурсоемкий этап алгоритма — эффективно распараллеливается по объектам после предварительного обращения матриц ковариаций и вычисления их определителей: при расчете скрытых переменных для фиксированного объекта информация о других объектах не используется. Также стоит отметить, что для всех объектов выполняется одна и та же последовательность действий. Таким образом, параллельная сложность E-шага — <math>O(k * n^{2})</math>.
* Менее ресурсоемкий шаг M распараллеливается хуже: промежуточные вычисления можно проводить независимо для каждого объекта, но после этого придется проводить агрегацию полученных результатов по кластерам.

=== Входные и выходные данные алгоритма ===
'''Входные данные:''' плотная матрица объектов-признаков <math>X \in \R^{l \times n}</math>, число кластеров <math>k \in \N</math>, максимальное число итераций <math>imax \in \N</math>, минимальная величина изменения логарифма правдоподобия <math>\varepsilon \in \R</math>.

'''Объём входных данных:''' <math>ln + 3</math>

'''Выходные данные:''' вещественный вектор весов <math>w \in \R^{k}</math>, <math>k</math> вещественных векторов математических ожиданий <math>\mu_{j} \in \R^{n}</math> и <math>k</math> вещественных ковариационных матриц <math>\Sigma_{j} \in \R^{n \times n}</math>.

'''Объём выходных данных:''' <math>k(n^{2}+n+1)</math>

=== Свойства алгоритма ===
Вычислительная мощность EM-алгоритма в предположении о том, что <math>l \gg n</math> (это условие выполняется в подавляющем большинстве прикладных задач), оценивается величиной <math>O(imax * k * n)</math>.

Достоинства EM-алгоритма:
* Мощная математическая основа
* Слабая чувствительность к выбросам
* Быстрая сходимость при удачной инициализации параметров
* Линейный рост сложности при увеличении количества объектов

Недостатки EM-алгоритма:
* В классическом варианте не может самостоятельно определить количество компонент смеси
* Трудоемкий и неустойчивый процесс обращения матриц ковариаций в случае несферических компонент смеси
* Не является детерминированным: в начале работы происходит инициализация начальных параметров случайным образом
* Не является устойчивым: результат работы сильно зависит от инициализации параметров. При неудачной инициализации может обладать низкой скоростью сходимости, может сойтись к локальному экстремуму или не сойтись вовсе

== Программная реализация алгоритма ==

=== Особенности реализации последовательного алгоритма ===

=== Локальность данных и вычислений ===

=== Возможные способы и особенности параллельной реализации алгоритма ===

=== Масштабируемость алгоритма и его реализации ===

=== Динамические характеристики и эффективность реализации алгоритма ===

=== Выводы для классов архитектур ===

=== Существующие реализации алгоритма ===
# [http://scikit-learn.org/stable/modules/generated/sklearn.mixture.GaussianMixture.html#sklearn.mixture.GaussianMixture scikit-learn(Python)]
# [http://docs.opencv.org/2.4/modules/ml/doc/expectation_maximization.html OpenCV(C++/Python)]
# [http://www.mlpack.org/docs/mlpack-git/doxygen.php?doc=classmlpack_1_1gmm_1_1GMM.html MLPack(C++)]
# [http://arma.sourceforge.net/docs.html#gmm_diag Armadillo(C++)]
# [https://www.mathworks.com/help/stats/fitgmdist.html Matlab]

== Литература ==

Обсуждение участника:Александр Куваев

2016-10-31T13:54:36Z

Algoman:

== Замечания к [[Участник:Александр_Куваев/Алгоритм_кластеризации,_основанный_на_максимизации_ожидания]] ==

1) отсутствует оценка вычислительной мощности алгоритма в п 1.10 - замечание исправлено

== Замечения от 31.10 ==

отсутствует ссылка на источник картинки в п 1.1
"- В конце статьи должен быть приведен список всех источников, откуда бралась информация по алгоритму. Если вы используется готовый рисунок, то сслыку на источник нужно разместить либо в подписи к рисунку, либо в тексте, где стоит ссылка на рисунок."

Обсуждение участника:Артем Таран

2016-10-31T13:52:58Z

Algoman:

== Замечания к [[Участник:Артем_Таран/Графо-ориентированный_алгоритм_кластеризации_CHAMELEON]] ==

1) отсутствует оценка вычислительной мощности алгоритма в п 1.10

== Замечения от 31.10 ==

отсутствует ссылка на источник картинки
"- В конце статьи должен быть приведен список всех источников, откуда бралась информация по алгоритму. Если вы используется готовый рисунок, то сслыку на источник нужно разместить либо в подписи к рисунку, либо в тексте, где стоит ссылка на рисунок."

Обсуждение участника:Артем Таран

2016-10-31T13:52:41Z

Algoman: