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

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

2017-02-04T16:44:27Z

Dexter: /* Статья Участник:Dmitry/Плотностный алгоритм кластеризации */

== Статья [[Участник:Dmitry/Плотностный алгоритм кластеризации]] ==
=== Дополнительные замечания ===
* Врезка - подозрительный объем выходных данных. Это ведь количество кластеров. Оно всегда равно количеству элементов в исходной выборке? Про параллельный алгоритм ничего

* В разделе 1.2 много определений, но ничего про алгоритм. MCP в одной формуле превратилось в MCP.

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

* В разделе 1.4 требуется привести описание алгоритма на верхнем уровне (на основе макроопераций). [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 16:50, 3 февраля 2017 (MSK)

=== Отсутствующие части ===
* Не заполнен раздел 2.4 описания. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 16:50, 3 февраля 2017 (MSK)

Участник:Руслан/Плотностный алгоритм кластеризации

2016-12-17T15:56:30Z

Dexter:

{{Assignment|Преподаватель 1|Dexter}}
{{Assignment|Sleo}}
{{algorithm
| name = Плотностный алгоритм кластеризации DBSCAN
| serial_complexity = <math>O(n \log n)</math>
| pf_height = <math>O(|X| \log |X|)</math>
| pf_width = <math>O(m)</math>
| input_data = <math>n</math>
| output_data = <math>n</math>
}}

Основной автор описания: [[User:Руслан|Кучеров Р.И.]]

Алгоритм '''DBSCAN (Density Based Spatial Clustering of Applications with Noise)''' - плотностный алгоритм для кластеризации пространственных данных с присутствием шума), был предложен Мартином Эстер, Гансом-Питером Кригель и коллегами в 1996 году как решение проблемы разбиения (изначально пространственных) данных на кластеры произвольной формы. Большинство алгоритмов, производящих плоское разбиение, создают кластеры по форме близкие к сферическим, так как минимизируют расстояние до центра кластера. Авторы DBSCAN экспериментально показали, что их алгоритм способен распознать кластеры различной формы.

= ЧАСТЬ. Свойства и структура алгоритма =
Кластеризация – это процесс разбиения множества элементов на непересекающиеся кластеры, так, чтобы в каждом кластере все элементы были схожи в каком-то смысле, а объекты разных кластеров существенно отличались.

== Общее описание алгоритма ==
Идея, положенная в основу алгоритма, заключается в том, что внутри каждого кластера наблюдается типичная плотность точек (объектов), которая заметно выше, чем плотность снаружи кластера, а также плотность в областях с шумом ниже плотности любого из кластеров. Ещё точнее, что для каждой точки кластера её соседство заданного радиуса должно содержать не менее некоторого числа точек, это число точек задаётся пороговым значением. Алгоритм DBSCAN для заданных значений параметров <math>\varepsilon</math> и MinPts исследует кластер следующим образом: сначала выбирает случайную точку, являющуюся ядровой, в качестве затравки, затем помещает в кластер саму затравку и все точки, плотно-достижимые из неё.

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

Исходные данные: объекты, которые нужно кластеризовать, параметры <math>MinPts, \ \varepsilon</math> . Между объектами можно считать расстояния.

Вычисляемые данные: разбиение объектов по кластерам. Количество кластеров зависит от исходных данных.

Для построения оценки плотности, на основе соседства точек вводятся понятия достижимости и связности. Под <math>\varepsilon</math> -соседями точки <math>x \in X</math> понимается множество точек, расстояние до которых не превышает <math>\varepsilon</math> , т. е. <math>N_\varepsilon (x) = \{y \in X | D(x, y) \le \varepsilon\}.</math> Тогда точка y достижима из точки <math>x</math>, если существует последовательность точек <math>x^{(1)}=x, x^{(2)},... , x^{(p-1)}, x^{(p)}=y</math>, для которой выполнено:

<math>\begin{align}
x^{(i+1)} \in N_\varepsilon (x^{(i)}), i=1,... ,p-1 \\
\mid N_\varepsilon (x^{(i)}) \mid \ge MinPts, i=1,... ,p-1
\end{align}</math>

Здесь значение <math>MinPts</math> задаётся пользователем и регулирует порог «шума». Согласно второму условию, у точек, находящихся внутри кластера, должно быть не менее <math>MinPts \ \varepsilon</math> -соседей. Такие точки называются «ядрами». Остальные точки разделяются на граничные (имеющие менее <math>MinPts \ \varepsilon</math> -cоседей, но достижимые из какого-либо «ядра») и шумовые. Две точки связны, если существует «ядро», из которого они обе достижимы. При такой постановке задачи, под кластером понимается максимальное связное подмножество множества X . Точки, не попавшие в какой-либо кластер (не принадлежащие <math>\varepsilon</math> -окрестности какого-либо «ядра»), относятся к классу «шум».

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

Вычислительное ядро последовательной версии зависти от поиска всех точек в <math>\varepsilon</math>-окрестности конкретной точки. Из-за поиска <math>\varepsilon</math>-соседства алгоритм имеет квадратичную вычислительную сложность <math>O(n^2)</math> (где n - количество точек). Но если задействовать K-мерное дерево, то можно снизить сложность до <math>O(\text{n log n})</math>.

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

Алгоритм DBSCAN использует пространственную структуру данных для определения соседних объектов. Это может быть R*-дерево или k-d дерево. Такие структуры данных позволяют найти все объекты в пределах определенного расстояния от текущего объекта. Также для построения этих деревьев нужно уметь находить расстояние между объектами <math>\rho(u, v)</math> , в, это расстояние можно вводить разными способами. Например, если <math>\rho(u,v)</math> - метрика в евклидовом пространстве, <math>u=(u_1,...,u_n)</math> и <math>(v_1,...,v_n)</math>, то расстояние вычисляется следующим образом: <math>\rho(u,v)=\sqrt{(u_1-v_1)^2+(u_2-v_2)^2+...+(u_n-v_n)^2} = \sqrt{\sum_{k=1}^n(u_k-v_k)^2}.</math>

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

Алгоритм начинает работу с произвольной точки <math>x \in X</math> и возвращает <math>\varepsilon</math> -окрестность(строка 4). Если <math>\varepsilon</math>-окрестность содержит, как минимум minpts точек, процедура выдает новый кластер C. Алгоритм извлекает все точки в X, которые являются плотность достижима из x и добавляет их в кластер C(строки 8-17). Если в <math>\varepsilon</math>-окрестности x точек меньше, чем minpts, то x помечается как шум(строка 6). Однако, х все еще может быть добавлены в кластер, если она определится как пограничная точка во время изучения других основных точек(строки 16-17). Поиск точек в <math>\varepsilon</math>-окрестности(функция GETNEIGHBORS)известен, как запрос в диапазоне значений и получает все плотностно достижимые точки от главной точки(строки 8-17) известный как алгоритм наращивания областей. Заметим что кластер может быть определен однозначно, начиная с любой "ядровой" точки<ref> A. Zhou, S. Zhou, J. Cao, Y. Fan, and Y. Hu, “Approaches for scaling DBSCAN algorithm to large spatial databases,” Journal of computer science and technology, vol. 15, no. 6, pp. 509–526, 2000.</ref>.

1: procedure DBSCAN(X, eps, minpts)
2: for each unvisited point x ∈ X do
3: mark x as visited
4: N ← GETNEIGHBORS(x, eps)
5: if |N| < minpts then
6: mark x as noise
7: else
8: C ← {x}
9: for each point x' ∈ N do
10: N ← N \ x'
11: if x' is not visited then
12: mark x' as visited
13: N' ← GETNEIGHBORS(x', eps)
14: if |N'| ≥ minpts then
15: N ← N ∪ N'
16: if x' is not yet member of any cluster then
17: C ← C ∪ {x'}

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

В общем случае алгоритм DBSCAN имеет квадратичную вычислительную сложность <math>O(n^2)</math>(где n это количество точек в X) из-за поиска <math>\varepsilon</math>-соседства. Но если использовать пространственную индексацию (например, использую k-мерное дерево<ref>M. B. Kennel, “KDTREE 2: Fortran 95 and C++ software to efficiently search for near neighbors in a multi-dimensional Euclidean space,” 2004, institute for Nonlinear Science, University of California.</ref> или R-дерево) для поиска <math>\varepsilon</math>-соседства, сложность снижается до <math>O(n log n)</math><ref>J. Bentley, “Multidimensional binary search trees used for associative searching,” Communications of the ACM, vol. 18, no. 9, pp. 509–517, 1975.</ref>.

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

На рисунке 1 представлен информационный граф алгоритма кластеризации DBSCAN. На входе у нас множество точек <math>P_i</math> и мы пробегаем по всем непосещенным точкам. Далее мы, для каждой непосещенной точки, маркируем ее как посещенную и находим всех её <math>\varepsilon</math>-соседей(на графике это узел <math>G</math>). Добавляем точку к кластеру(узел <math>C</math>). Затем, пробегаем по всем плотностно-достижимых точках(<math>P_j</math>) к нашей точке, и для каждой такой точки ищем <math>\varepsilon</math>-сосдей и добавляем их в кластер, если они ещё не принадлежат никакому кластеру.

[[file:Информационный_граф.png|thumb|center|700px|Рис.1 Граф алгоритма без отображения входных и выходных данных. <math>P_i</math> и <math>P_j</math> - точки данного множества, <math>G</math> - поиск <math>\varepsilon</math>-соседей, <math>C</math> - добавление элемента к кластеру.]]

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

Поиск <math>\varepsilon</math>-соседей требует вычисления n расстояний и выполнения n сравнений с <math>\varepsilon</math>. Эти операции для каждой пары точек независимы и могут быть выполнены параллельно. Таким образом, при наличии неограниченного числа процессоров сложность поиска составит O(1). Так как поиск выполняется для каждой точки ровно один раз, параллельная сложность всего алгоритма составит O(n).

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

Входные данные: набор точек x, пороговое расстояние <math>\varepsilon</math>, а также минимальное количество точек, необходимых для формирования кластера, minpts.

Выход: множество кластеров С.

Если указать маленькое значение <math>\varepsilon</math>, то все точки будут шумом. Если наоборот, сделать большое значение, то кластер не будет разбит, возьмет один кластер и включит в него все точки. Также, если взять minpts слишком большое или слишком маленькое, будет либо один кластер, либо все точки шумовые. Оптимальные значения находятся опытным путем.

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

=== Преимущества алгоритма ===
* не требует указать априори количество кластеров, в отличие от K-средства

* алгоритм может разбить на произвольной формы кластеры. Даже может выявить кластер находящийся внутри другого, но не пересекающийся с ним. Из-за параметра MinPts снижается так называемый эффект однолокальности(single-link)

* алгоритм имеет понятие "шума" и устойчив к выбросам

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

* параметры MinPts и <math>\varepsilon</math> могут быть установлены, экспертами в какой-либо области, если данные хорошо изучены.

=== Недостатки алгоритма ===

* алгоритм не совсем детерминирован: пограничные точки, которые доступны из более чем одного кластера могут быть частью любого кластера, в зависимости от того, как происходит обработка данных. К счастью, эта ситуация не часто возникают, и мало влияет на результат кластеризации. На основных точках и точках "шума", алгоритм детерминирован. Есть DBSCAN<ref>Campello, R. J. G. B.; Moulavi, D.; Sander, J. (2013). Density-Based Clustering Based on Hierarchical Density Estimates. Proceedings of the 17th Pacific-Asia Conference on Knowledge Discovery in Databases, PAKDD 2013. Lecture Notes in Computer Science. p. 160.</ref> который представляет собой вариант, который рассматривает пограничные пункты как шум, и таким образом достигается полностью детерминированный результат, а также более последовательной статистической интерпретации плотности соединенных компонентов.

* качество алогоритма зависит от меры, которую мы рассматриваем в пространстве. Наиболее распространенная мера использует евклидово расстояние.

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

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

= ЧАСТЬ. Программная реализация алгоритма =

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

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

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

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

Было проведено исследование масштабируемости параллельной реализации алгоритма DBSCAN. Исследование проводилось на суперкомпьютере "Ломоносов". Исследовалась параллельная реализация алгоритма, написанная с использованием стандарта MPI. Распараллеливание проводилось по числу входных объектов.

[[file:DbscanPerfomance.png|thumb|center|700px|Рис.2 График масштабируемости]]

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

При увеличении размерности системы при фиксированном количестве процессов на области изменений значений параметров наблюдается увеличение эффективности.

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

[https://github.com/ruslanmsk/parallel_dbscan Параллельная реализация на языке C++]

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

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

== Существующие реализации алгоритма ==
[//en.wikipedia.org/wiki/ELKI ELKI] предлагает реализацию DBSCAN, а также GDBSCAN и другие варианты. Эта реализация может использовать различные структуры индексов для поквадратного выполнения и поддерживает произвольное расстояние функции и произвольные типы данных, но это можно обогнать низкоуровневой оптимизацией реализации на небольших наборах данных.

[//en.wikipedia.org/wiki/Scikit-learn Scikit-Learn] включает в себя реализацию Python для DBSCAN для произвольной метрики Минковского, который может быть ускорен с помощью KD-деревьев и шаровых деревьев, но который использует в худшем случае квадратичную память.

[//en.wikipedia.org/wiki/R_(programming_language) GNU R] содержит DBSCAN в [//cran.r-project.org/web/packages/fpc/index.html fpc] пакете с поддержкой произвольных функций расстояния через матриц. Однако он не имеет поддержки индекса (и, соответственно, имеет квадратичное время выполнения и сложность по памяти) и довольно медленно из-за интерпретации R. Более быстрая версия реализована на языке C++ с использованием KD-деревьев (только когда расстояние Евклидово ) в пакете R [//cran.r-project.org/web/packages/dbscan/index.html dbscan].

[//www.philippe-fournier-viger.com/spmf/SPMF SPMF] предлагает GPL-V3 java-реализацию алгоритма DBSCAN с поддержкой KD-дерева (только для параметра расстояние Евклида).

[//en.wikipedia.org/wiki/Weka_(machine_learning) Weka] содержит (как дополнительный пакет в последних версиях) базовую реализацию DBSCAN, которая работает за квадратичное время и линейную память.

[//en.wikipedia.org/wiki/Apache_Commons Apache Commons Мath] содержит java-реализацию алгоритма выполняющегося за квадратичное время.

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

* Ester, Martin, et al. "A density-based algorithm for discovering clusters in large spatial databases with noise." Kdd. Vol. 96. No. 34. 1996.

* Воеводин В.В. Математические основы параллельных вычислений// М.: Изд. Моск. ун-та, 1991. 345 с.

* Воеводин В.В., Воеводин Вл.В. Параллельные вычисления. – СПб.: БХВ - Петербург, 2002. – 608 с.

* Фролов А.В.. Принципы построения и описание языка Сигма. Препринт ОВМ АН N 236. М.: ОВМ АН СССР, 1989.

Участник:Maria Zaitseva/PAM (Partitioning Around Medoids)

2016-12-17T15:55:27Z

Dexter:

{{Assignment|Преподаватель 1|Dexter}}
{{Assignment|ASA}}
{{Assignment}}

{{algorithm
| name = Partitioning Around Medoids
| serial_complexity = <math>O(Tkn^2)</math>
| input_data = <math>\frac{n (n - 1)}{2}</math>
| output_data = <math>k</math>
| pf_height = <math>O(Tkn)</math>
| pf_width = <math>O(k(n-k))</math>
}}

Авторы: [[Участник: Maria Zaitseva|Зайцева М.Ф.]], [[Участник: kovalexal|Ковальчук А.А.]].

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

'''PAM (Partitioning Around Medoids)''' – алгоритм разбиения множества объектов на [https://ru.wikipedia.org/wiki/Кластер кластеры], базирующийся на использовании наиболее представительных объектов каждого кластера ([https://ru.wikipedia.org/wiki/Медоид медоидов]) для их описания. Был разработан в 1987 году Леонардом Кауфманом и Питером Русивом <ref>Kaufman L., Rousseeuw P. J. Finding groups in data: an introduction to cluster analysis. – John Wiley & Sons, 2009. – Т. 344.</ref>. Показывает хорошие результаты разбиения на небольших наборах данных, однако имеет высокую вычислительную сложность, ввиду чего неэффективно работает на больших наборах данных.

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

== Общее описание алгоритма ==
Данный алгоритм используется для решения задачи [https://ru.wikipedia.org/wiki/Кластерный_анализ кластеризации] множества объектов на заранее известное число кластеров <math>k</math>. Каждый кластер характеризуется наиболее представительным (центральным ) объектом – медоидом. Принадлежность объекта к соответствующему кластеру определяется индексом наиболее близкого к нему медоида.

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

Алгоритм состоит из двух последовательных этапов:

1. Шаг ''BUILD''. Построение начального набора <math>k</math> медоидов путем их последовательного выбора. Первый из них выбирается как объект, сумма дистанций которого до всех других объектов минимальна (центральный объект). Каждый следующий выбирается из оставшихся объектов как лучше всего минимизирующий сумму расстояний от объектов до ближайших к ним медоидов. Выбранный набор медоидов характеризует "конфигурацию" кластеров, для которой может быть вычислена ее стоимость.

2. Шаг ''SWAP''. На данном шаге производится попытка улучшить стоимость текущей конфигурации путем перебора всех возможных замен (медоид-немедоид). Среди рассматриваемых конфигураций ищется наиболее оптимальная. В случае, если данная конфигурация по стоимости лучше текущей, она принимается в качестве текущей и шаг повторяется с начала, иначе алгоритм завершается.

Преимущества данного алгоритма по сравнению с подобными ему:

* В отличие от более популярного алгоритма [https://ru.wikipedia.org/wiki/K-means k-means], PAM позволяет работать с произвольными объектами с заданной мерой рассчета расстояний (различий), не требует хранения всего множества объектов (достаточно знать лишь матрицу дистанций, так как медоиды выбираются из множества объектов), а также более устойчив к выбросам в данных (за счет рассмотрения медоидов вместо центроидов);
* В отличие от традиционного [https://en.wikipedia.org/wiki/K-medoids k-medoids] на шаге ''BUILD'' начальные медоиды выбираются более оптимальным образом по сравнению со случайным выбором. Это позволяет уменьшить количество итераций шага ''SWAP'', тем самым сокращая время работы алгоритма.

Недостатком данного алгоритма является неэффективность при больших наборах данных ввиду необходимости полного перебора.

== Математическое описание алгоритма ==
''Входные данные'':

* <math>o = \{1,\dots,n\} \subset \mathbb{Z}</math> –– множество индексов объектов
* <math>O = \{O_1,\dots,O_n\}</math> –– множество объектов
* <math>k \leq n</math> –– количество кластеров для разбиения
* <math>d:O\times O\rightarrow \mathbb{R}^{1}</math> –– метрика расчета расстояний между объектами, <math>d_{ij} = d(O_i,O_j)</math>
* <math>D\in \mathbb{R}^{n\times n}</math> –– симметрическая матрица дистанций объектов, где <math>D=(d_{ij}), i \in o, j \in o</math>

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

* <math>m = \{m_1,\dots,m_k\}\subset o</math> –– множество индексов объектов, принятых в качестве медоидов; <math> M </math>--множество медоидов.

Принадлежность объекта к определенному кластеру определяется как индекс ближайшего к нему медоида:
:<math>g_m(i)=\arg \min_{m_j\in m} d_{im_j}</math>.

Основная задача состоит в выборе такого множества индексов медоидов <math>m</math>, наилучшим образом минимизирующего функционал:
:<math>F_o(m) = \sum_{j \in o \backslash m} d_{jg_m(j)}</math>.

Введем обозначения:

* <math>D_j = d_{jg_m(j)}</math> –– индекс первого по близости к j медоида
* <math>E_j = d_{jg_{m \backslash g_m(j)}(j)}</math> –– индекс второго по близости к j медоида

Решение задачи состоит из следующих шагов:

1. Шаг ''BUILD''

1.1. Выбор первого медоида
:<math>m=\{ \arg \min_{i \in o} \sum_{j \in o} d_{ij} \}</math>

1.2 Последовательный выбор оставшихся медоидов до тех пор, пока <math>\left\vert{m}\right\vert \neq k</math>
:<math>m = m \cup \{ \arg \max_{i \in o \backslash m} \sum_{j \in o \backslash \{m \cup i\} } \max (D_j - d_{ji}, 0) \}</math>

2. Шаг ''SWAP''

2.1. Производится перебор всех возможных пар медоид-немедоид <math>(i, h): i \in m, h \in o \backslash m</math>, для каждой из которых рассчитывается стоимость смены текущей конфигурации <math>T_m(i,h)</math>. При смене конфигурации множество медоидов изменяется <math>m = m \cup \{h\} \backslash \{i\}</math>.
:<math>T_m(i, h) = \sum_{j \in o \backslash \{m \cup h\}} C_{jih}</math>, где <math>C_{jih}</math> –– вклад объекта <math>j</math> в перестановку медоида <math>i</math> и не медоида <math>h</math>.
При этом <math>C_{jih}</math> рассчитывается по-разному в зависимости от положения <math>j</math> относительно <math>i</math> и <math>h</math> (<math>j</math> дальше от <math>i</math> и от <math>h</math>, чем от своего ближайшего медоида; <math>i</math> оказался ближайшим медоидом <math>j</math>; <math>j</math> оказался дальше от <math>i</math>, но ближе к <math>h</math>, чем к своему медоиду).
:<math>C_{jih} = \left\{\begin{matrix}
0, & d_{ji} > D_j, d_{jh} > D_j \\
d_{jh} - d_{ji}, & d_{ji} = D_j, d_{jh} < E_j \\
E_j - D_j, & d_{ji} = D_j, d_{jh} \geqslant E_j \\
d_{jh} - D_j, & d_{ji} > D_j, d_{jh} < D_j
\end{matrix}\right.</math>
Среди всех пар находится такая пара <math>(i_s, h_s)</math>, что <math>T_m(i_s, h_s)</math> минимально.

2.2 В случае, если <math>T_m(i_s, h_s) \geq 0</math>, смена конфигурации медоидов не производится и решение задачи окончено. Иначе производится смена конфигурации и повторяется шаг 2.1.

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

<math>F_{m} = \max_{i \in o \backslash m} \sum_{j \in o \backslash \{m \cup i\} } \max (D_j - d_{ji}, 0)</math>

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

Вычислительное ядро алгоритма на этапе ''SWAP'' состоит в расчете функции минимизации стоимости изменения конфигурации <math>T_m(i, h)</math> при замене медоида <math>i</math> на немедоид <math>h</math> в текущей конфигурации для всех возможных <math>(i, h): i \in m, h \in o \backslash m</math>:

<math>T_m(i, h) = \sum_{j \in o \backslash \{m \cup h\}} C_{jih}</math>.

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

1. Макрооперация "Выбор следующего медоида"
:<math>m = m \cup \{ \arg \max_{i \in o \backslash m} \sum_{j \in o \backslash \{m \cup i\} } \max (D_j - d_{ji}, 0) \}</math>

2. Макрооперация "Вычисление стоимости смены текущей конфигурации"
:<math>T_m(i, h) = \sum_{j \in o \backslash \{m \cup h\}} C_{jih}</math>

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

1. Фаза ''BUILD''

На данном шаге осуществляется выбор первого медоида. Далее осуществляется макрооперация "Выбор следующего медоида" <math>(k - 1)</math> раз.

2. Фаза ''SWAP''

На данном шаге для всех возможных комбинаций медоид-немедоид осуществляется макрооперация "Вычисление стоимости смены текущей конфигурации". Данная операция производится <math>k(n-k)</math> раз для каждой итерации. Среди всех комбинаций выбирается та замена, стоимость которой максимальна.

3. ''Критерий останова''

:<math>T_m(i, h) < 0</math>

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

''Псевдокод алгоритма'':

'''Вход''': Объем входных данных: <math>n\times n + 2</math>. Матрица дистанций D (<math>n\times n</math> вещественных чисел); количество кластеров <math>k \in \mathbb{Z}</math>; максимальное количество итераций алгоритма <math>maxIter \in \mathbb{Z}</math>
'''Выход''': Объем выходных данных: <math>k</math>. Множество индексов медоидов <math>m = \{m_1, \dots, m_k\} \subset \mathbb{Z}</math>
1 # Фаза BUILD
2 Выбор стартового объекта в качестве начального медоида: m = {первый медоид}
3 Пока |m| != k:
4 Выбор следующего медоида i_m
5 Добавление найденного медоида в множество: m = m + {i_m}
6 # Фаза SWAP
7 Пока (maxIter--):
8 Лучшая стоимость замены: Tbest = MAXINT
9 Кандидаты на замену: (i_s, h_s) = (-1, -1)
10 Для всех i из множества медоидов:
11 Для всех j из множества немедоидов:
12 Расчет стоимости замены Tm(i,h)
13 Если Tm(i, h) < Tbest:
14 Tbest = Tm(i, j)
15 Запомнить найденные кандидаты: (i_s, j_s) = (i, h)
16 Если Tbest >= 0:
17 Выход
18 Иначе:
19 m = m + {h} - {i}

На фазе ''BUILD'' осуществляется построение начального множества медоидов. Данный процесс производится итерационно до тех пор, пока не будет найдено необходимое число медоидов.
На фазе ''SWAP'' производится попытка улучшить множество выбранных медоидов. Данный процесс также производится итерационно то тех пор, пока целевая функция не перестанет улучшаться. Также, для данного шага можно ввести ограничение по числу производимых алгоритмом итераций.

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

Для осуществления шага ''BUILD'' потребуется:

* <math>n^2</math> операций сложения и <math>n</math> операций сравнения для выбора начального медоида;
* <math>\sum_{l=1}^{k-1} (2(n-l) \cdot (n-l-1)+(n-l))=\frac{1}{6}(k-1)(4k^2 - 12kn + k + 6n(2n-1))</math> операций сложения, вычитания и сравнения для всех итераций выбора медоидов.

Таким образом, последовательная сложность шага ''BUILD'' оценивается как <math>O(kn^2)</math>.

Для осуществления каждого шага ''SWAP'' потребуется:

* <math>2k(n-k)(n-k-1)</math> операций вычитания и сложения;
* <math>k(n-k)</math> операций сравнения;

Таким образом, последовательная сложность каждого шага ''SWAP'' оценивается как <math>O(kn^2)</math>.
Заранее число итераций шага ''SWAP'' неизвестно, поэтому принимаем его равным <math>T</math>. Отсюда, общая последовательная сложность алгоритма PAM оценивается как <math>O(Tkn^2)</math>.

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

=== Информационный граф шага BUILD ===
На рис.1 показана информационная структура шага BUILD алгоритма PAM на некотором шаге.

[[file:Pam_build.png|thumb|center|553px|Рис.1. Информационная структура шага BUILD алгоритма PAM на шаге <math>t</math>]]

''Операции'':
* <math>sum_{o,m_t}(i) = \sum_{j \in o \backslash \{m \cup i\}} \max (D_j, d_{ji})</math> –– оценка конфигурации при внесении <math>i</math> в множество индексов медоидов <math>m</math> с множеством объектов <math>o</math>;
* <math>\arg \max</math> –– индекс объекта, дающего наибольшую оценку конфигурации при его внесении в множество индексов медоидов <math>m</math>;
* <math>update(m)</math> –– операция добавления индекса объекта в множество индексов медоидов <math>m</math>.

=== Информационный граф шага SWAP ===
На рис.2 показана информационная структура шага SWAP алгоритма PAM на некотором шаге.

[[file:Pam_swap_new.png|thumb|center|553px|Рис.2. Информационная структура шага SWAP алгоритма PAM на шаге <math>t</math>]]

''Операции'':
* <math>T_m(i, h) = \sum_{j \in o \backslash \{m \cup h\}} C_{jih} </math> –– стоимость смены конфигурации при замене немедоида <math>h</math> медоидом <math>i</math> в текущей конфигурации <math>m</math>;
* <math>\arg \min</math> –– пара <math>(i, h)</math> (медоид-немедоид), замена которой в текущей конфигурации <math>m</math> дает наименьшую стоимость смены;
* <math>swap</math> –– операция замены медоида <math>i</math> на немедоид <math>h</math> в текущей конфигурации <math>m</math>, если стоимость смены отрицательна.

== Ресурс параллелизма алгоритма ==
Для осуществления шага ''BUILD'' потребуется:

* <math>n</math> параллельных операций сложения и <math>n</math> последовательных операций сравнения для выбора начального медоида;
* <math>\sum_{l=1}^{k-1} 2(n-l) = (k-1)(2n-k)</math> параллельных операций сложения и вычитания для всех итераций выбора медоидов;
* <math>\sum_{l=1}^{k-1} n-l = \frac{1}{2}(k-1)(2n-k)</math> последовательных операций сравнения для всех итераций выбора медоидов.

Таким образом, параллельная сложность шага ''BUILD'' оценивается как <math>O(kn)</math>.

Для осуществления каждого шага ''SWAP'' потребуется:

* <math>k(n-k) </math> параллельных операций вычитания и сложения;
* <math>k(n-k)</math> последовательных операций сравнения.

Таким образом, параллельная сложность каждого шага ''SWAP'' оценивается как <math>O(kn)</math>.
Заранее число итераций шага ''SWAP'' неизвестно, поэтому принимаем его равным <math>T</math>. Отсюда, общая параллельная сложность алгоритма PAM оценивается как <math>O(Tkn)</math>.

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

''Входные данные'':
* Массив <math>V</math> из <math>\frac{n(n-1)}{2}</math> вещественных чисел, определяющий набор дистанций между всеми парами объектов (сжатая матрица дистанций). Симметрическая матрица дистанций <math>D\in \mathbb{R}^{n\times n}</math> восстанавливается из этого массива однозначным образом (для восстановления необходимо знать число объектов <math>n</math>):
:<math>D(i, j)=\left\{\begin{matrix}
V[ni - \frac{i(i + 1)}{2} + (j - i - 1)], & i < j\\
V[nj - \frac{j(j + 1)}{2} + (i - j - 1)], & i > j \\
0, & i = j
\end{matrix}\right.</math>

* Целое число кластеров <math>k</math>, на которое необходимо разбить множество объектов.

''Выходные данные'':
* Множество <math>m</math>, состоящее из <math>k</math> индексов объектов, принятых в качестве медоидов. Индекс кластера, которому принадлежит объект с индексом <math>i</math> можно восстановить с использованием функции <math>g_m(i)=\arg \min_{m_j\in m} d_{im_j}</math>.

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

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

2. ''Вычислительная мощность'' последовательного алгоритма, как отношение числа операций к суммарному объему входных и выходных данных: <math> O(Tk) </math>.

3. Алгоритм является ''устойчивым'', так как все операции в алгоритме не подвержены накоплению ошибки.

4. Алгоритм является ''не детерминированным'', так как не детерминирован выбор набора медоидов, на которых достигается наилучшая конфигурация.

5. Имеет высокую вычислительную сложность (квадратичную) ввиду необходимости полного перебора, поэтому неэффективно работает на больших наборах данных.

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

7. Устойчив к выбросам данных (за счет рассмотрения медоидов).

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

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

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

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

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

Для изучения масштабируемости алгоритма была выполнена его [https://gitlab.com/kovalexal/pam-lomonosov реализация] с использованием механизма MPI на языке программирования C++. Данная реализация использует библиотеку [http://www.boost.org Boost] (модуль MPI для удобного взаимодействия C++ и MPI и модуль uBLAS для работы с матрицами). Исследование масштабируемости описанной реализации производилось на суперкомпьютере [https://parallel.ru/cluster/lomonosov.html "Ломоносов"]. Для сборки программы использовался компилятор gcc версии 5.2.0 с опциями "-std=c++11 -O3" совместно с OpenMPI версии 1.8.4.

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

[[file:points.png|thumb|center|553px|Рис.3. Пример сгенерированных данных – 20 кластеров, 5000 точек]]

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

* Число процессов: [1, 8, 16, 32, 48, 50, 51, 64, 99, 100, 101, 128, 160, 192, 200, 224, 256, 320, 384, 448, 512]
* Число кластеризуемых элементов: от 1000 до 5000 с шагом 250
* Число кластеров при расчете: 20

Для оценки производительности алгоритма осуществлялся расчет числа операций с плавающей запятой в секунду (FLOPs или GFLOPs). Для этого при каждом запуске рассчитывалось время работы алгоритма, число итераций шага ''SWAP'', по данным значениям можно получить точное число операций сложения, вычитания и сравнения вещественных чисел (оно равно последовательной сложности алгоритма), поделив его на время работы можно получить оценку числа FLOP в секунду. График изменения производительности в зависимости от числа процессоров и числа кластеризуемых элементов представлен ниже. Интерактивный график доступен по [https://plot.ly/~kovalexal/7/ ссылке].

[[file:PAM_perf.png|thumb|center|553px|Рис.4. Изменение производительности в зависимости от числа процессоров и числа кластеризуемых элементов]]

Масштабируемость алгоритма была получена путем деления реальной производительности на пиковую произвдительность <math>s</math> задействованных ядер (пиковая производительность одного ядра "Ломоносова" составляет ''5.686'' GFLOPs). График изменения эффективности в зависимости от числа процессоров и числа кластеризуемых элементов представлен ниже. Интерактивный график доступен по [https://plot.ly/~kovalexal/9/ ссылке].

[[file:PAM_eff.png|thumb|center|553px|Рис.5. Изменение эффективности в зависимости от числа процессоров и числа кластеризуемых элементов]]

Из полученных значений эффективности можно оценить диапазон эффективности реализации алгоритма:

* минимальная эффективность: 0.10353% достигается при использовании 512 процессов для кластеризации 1000 элементов на 20 кластеров;
* максимальная эффективность: 0.47637% достигается при использовании 1 процесса для кластеризации 2000 элементов на 20 кластеров.

Построим оценки масштабируемости выбранной реализации алгоритма Partitioning Around Medoids согласно [[Scalability_methodology]]:

* По числу процессов: 6.07542E-04. При увеличении числа процессов эффективность реализации на рассмотренной области значений параметров запуска возрастает, но интенсивность данного роста мала. Для увеличения масштабируемости по числу процессов необходимо увеличить количество операций в секунду, осуществляемых каждым процессом (например, уменьшив время работы алгоритма). Для этого можно применить различные технологии распараллеливания и векторизации вычислений.
* По размеру задачи: 1.91151E-04. При увеличении размера задачи эффективность возрастает, однако данный рост достаточно слаб. Это говорит нам о том, что эффективность алгоритма слабо зависит от размера входной задачи.
* По двум направлениям: 2.03868E-05. При рассмотрении увеличения как размера входа, так и числа процессов на всей рассмотренной области значений эффективность увеличивается, однако скорость увеличения эффективности небольшая. В совокупности с тем фактом, что разница между минимальной и максимальной эффективностью на рассмотренной области параметров небольшая, эффективность с увеличением масштабов возрастает, но медленно.

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

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

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

1. Последовательные реализации

* В [https://www.mathworks.com/help/stats/kmedoids.html?requestedDomain=www.mathworks.com#namevaluepairs MATLAB] ([https://ru.wikipedia.org/wiki/Коммерческое_программное_обеспечение Commercial software])
* [http://elki.dbs.ifi.lmu.de/browser/elki/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/KMedoidsPAM.java ELKI] на языке JAVA (Свободное распространение ([https://ru.wikipedia.org/wiki/GNU_Affero_General_Public_License AGPL]))
* В пакете [https://cran.r-project.org/package=cluster Cluster] на языке R (Свободное распространение ([https://ru.wikipedia.org/wiki/GNU_General_Public_License#GPL_v1 GPL]))
* В пакете [https://cran.r-project.org/package=ClusterR ClusterR] на языке R (Свободное распространение ([https://ru.wikipedia.org/wiki/Лицензия_MIT MIT]))

2. Параллельные реализации

* В пакете [https://cran.r-project.org/package=sprint SPRINT] на языке R (Свободное распространение ([https://ru.wikipedia.org/wiki/GNU_General_Public_License#GPL_v1 GPL]))

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

[[en:Description of algorithm properties and structure]]

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

2016-12-16T11:09:06Z

Dexter:

{{Assignment|Преподаватель 1|Dexter}}

{{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>n_{dw}</math> здесь понимается абсолютная частота встречаемости слова <math>w</math> в документе <math>d</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>U. \cdot V</math>,
* Поэлементного деления вектора на вектор <math>U. / 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 />

[[Категория:Незаконченные статьи]]
[[Категория:ЕМ-алгоритм]]

Участник:Казаков Артем/Алгоритм концептуальной кластеризации COBWEB

2016-12-12T14:27:31Z

Dexter:

{{Assignment|Преподаватель 1|Dexter}}
{{Assignment|ASA}}

{{algorithm
| name = Алгоритм концептуальной кластеризации COBWEB
| serial_complexity = <math>O(N*logN*B^{2}AV)</math>
| parallel_complexity = <math>O(N*logN*log(BAV))</math>
}}

Автор статьи: [[Участник: Казаков Артем|Артем Казаков]] (группа 624)

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

== Общее описание алгоритма ==
Алгоритм '''COBWEB'''<ref name="wiki" /><ref name="paper" /> — классический метод инкрементальной концептуальной кластеризации. Он создаёт иерархическую кластеризацию в виде дерева классификации: каждый узел этого дерева ссылается на концепт (концепт — описание группы объектов через определенный набор пар аттрибут-значение) и содержит вероятностное описание этого концепта, которое включает в себя вероятность принадлежности концепта к данному узлу.<ref name="habr" />

Узлы, находящейся на определённом уровне дерева классификации, называют срезом. Алгоритм использует для построения дерева классификации эвристическую меру оценки, называемую полезностью категории — прирост ожидаемого числа корректных предположений о значениях атрибутов при знании об их принадлежности к определённой категории относительно ожидаемого числа корректных предположений о значениях атрибутов без этого знания. Чтобы встроить новый объект в дерево классификации, алгоритм '''COBWEB''' итеративно проходит всё дерево в поисках «лучшего» узла, к которому отнести этот объект. Выбор узла осуществляется на основе помещения объекта в каждый узел и вычисления полезности категории получившегося среза. Также вычисляется полезность категории для случая, когда объект относится к вновь создаваемому узлу. В итоге объект относится к тому узлу, для которого полезность категории наибольшая.

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

== Математическое описание алгоритма ==
Обозначим:
* <math>\{ A_{1}, A_{2}, ... \}</math> — множество свойств кластеризуемых объектов
* <math>\{ u_{1j}, u_{2j}, ... \}</math> — возможнные значения свойства <math>A_{j}</math>
* <math>\{ C_{1}, C_{2}, ... \}</math> — множество категорий

<math>P(A_j = u_{ij} | C_k)</math> — это условная вероятность, с которой свойство <math>A_{j}</math>, принимает значение <math>u_{ij}</math>, если объект относится к категории <math>C_{k}</math>. Для каждой категории в иерархии определены вероятности вхождения всех значений каждого свойства. При предъявлении нового экземпляра система '''COBWEB''' оценивает качество отнесения этого примера к существующей категории и модификации иерархии категорий в соответствии с новым представителем. Критерием оценки качества классификации является полезность категории (''category utility'').

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

<math>CU = \sum_{k} \sum_{i} \sum_{j} P(A_j = u_{ij}|C_k) P(C_k|A_j = u_{ij}) P(A_j = u_{ij})</math><ref name="shit" />

Значения суммируются по всем категориям <math>C_k</math>, всем свойствам <math>A_j</math> и всем значениям свойств <math>u_{ij}</math>. Значение <math>P(A_j = u_{ij} | C_k)</math> называется предсказуемостью (predictability). Это вероятность того, что объект, для которого свойство <math>A_j</math> принимает значение <math>u_{ij}</math>, относится к категории <math>C_k</math>. Чем выше это значение, тем вероятнее, что свойства двух объектов, отнесенных к одной категории, имеют одинаковые значения. Величина <math>P(C_k | A = u_{ij})</math> называется предиктивностью (predictiveness). Это вероятность того, что для объектов из категории <math>C_k</math> свойство <math>A_j</math> принимает значение <math>u_{ij}</math>. Чем больше эта величина, тем менее вероятно, что для объектов, не относящихся к данной категории, это свойство будет принимать указанное значение. Значение <math>P(A = u_{ij})</math> — это весовой коэффициент, усиливающий влияние наиболее распространенных свойств. Благодаря совместному учету этих значений высокая полезность категории означает высокую вероятность того, что объекты из одной категории обладают одинаковыми свойствами, и низкую вероятность наличия этих свойств у объектов из других категорий.

== Вычислительное ядро алгоритма ==
Основное время работы алгоритма приходится на вычисление полезности категории.

Обозначим:

* <math>B</math> — среднее число потомков узлов в дереве классификации
* <math>N</math> — число объектов для классификации
* <math>A</math> — числа свойств у классифицируемых объектов
* <math>V</math> — среднее число значений, которые могут принимать свойства

На каждом шаге алгоритма (всего <math>N</math> производится спуск по дереву (<math>O(log_{B}N)</math>). На каждой итерации спуска производится <math>O(B)</math> вычислений полезности категории <math>CU</math>, вычисление каждой из которых имеет сложность <math>O(BAV)</math>.

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

== Макроструктура алгоритма ==
В алгоритме '''COBWEB''' реализован метод поиска экстремума в пространстве возможных кластеров с использованием критерия полезности категорий для оценки и выбора возможных способов категоризации.

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

== Схема реализации последовательного алгоритма ==
Алгоритм повторяется для каждого нового объекта. В данном алгоритме происходит спуск по дереву и на каждом шаге спуска выбирается одно из действий описанных в п. 1.4.

<pre>cobweb(Node, Instance)
Begin
if узел Node - это лист, then
begin
создать два дочерних узла L1 и L2 для узла Node;
задать для узла L1 те же вероятности, что и для узла Node;
инициализировать вероятности для узла L2 соответствующими значениями объекта Instance;
добавить Instance к Node, обновив вероятности для узла Node ;
end
else
begin
добавить Instance к Node, обновив вероятности для узла Node;
для каждого дочернего узла С узла Node вычислить полезность категории при отнесении экземпляра Instance к категории С;
пусть S1 - значение полезности для наилучшей классификации C1;
пусть S2 - значение для второй наилучшей классификации C2;
пусть S3 - значение полезности для отнесения экземпляра к новой категории;
пусть S4 - значение для слияния C1 и C2 в одну категорию;
пусть S5 - значение для разделения C1 (замены дочерними категориями);
end
if S1 - максимальное значение CU, then
cobweb(C1, Instance) %отнести экземпляр к C1
else
if S3 - максимальное значение CU, then
инициализировать вероятности для новой категории Cm значениями Instance
else
if S4 - максимальное значение CU, then
begin
пусть Cm - результат слияния C1 и C2;
cobweb(Cm, Instance);
end
else
if S5 - максимальное значение CU, then
begin
разделить C1; % Cm - новая категория
cobweb(Cm, Instance)
end;
end</pre>

== Последовательная сложность алгоритма ==
Последовательная сложность алгоритма равна <math>O(N*log_{B}N*B^{2}AV)</math>

где:
* <math>B</math> — среднее число потомков узлов в дереве классификации
* <math>N</math> — число объектов для классификации
* <math>A</math> — числа свойств у классифицируемых объектов
* <math>V</math> — среднее число значений, которые могут принимать свойства

Обоснование сложности приводится в п. 1.3.

== Информационный граф ==
[[file:Cobweb-flow-2.png|thumb|center|750px|Рис. 1 Информационный граф алгоритма COBWEB]]

<math>N_0</math> — корневой узел

<math>N_{11}, N_{12}, ..., N_{1L}</math> — узлы первого уровня

<math>N_{21}, N_{22}, ..., N_{2L}</math> — узлы второго уровня

<math>N_{B1}, N_{B2}, ..., N_{BL}</math> — узлы последнего уровня

<math>C_1, C_2, ..., C_L</math> — шаги спуска по дереву

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

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

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

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

* распараллеливание процесса вычисления совокупности функций полезности
* распараллеливание вычисления каждой конкретной функции полезности

Оба данных подхода к распараллеливанию могут быть использованы вместе.

* При неограниченном ресурсе параллелизма, вычисление функции полезности может быть произведено за <math>O(log(BAV))</math> через независимое вычисление каждой её составной части (за <math>O(1)</math>) и последующую их параллельную редукцию за <math>O(log(q))</math>, где <math>q=BAV</math> — количество составных частей функции полезности.
* Вычисление совокупности функций полезности (которых <math>O(B)</math>) также может быть распараллелено c последующей параллельной редукцией за <math>O(log(B))</math> и итоговой параллельной сложностью <math>O(log(BAV)+log(B))=log(BAV))</math> (при неограниченном ресурсе параллелизма).
* Продвижение объектов по дереву может не может быть распараллелено, поскольку входные данные для каждой очередной итерации зависят от результата выполнения предыдущей. Всего за время работы алгоритма выполняется <math>O(N*logN)</math> операций продвижения по дереву.

Таким образом, итоговая параллельная сложность алгоритма равна <math>N*logN*log(BAV)</math>.

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

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

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

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

Оценка вычислительной мощности алгоритма составляет <math>O(N * B * V * (A + logN))</math>.

= ЧАСТЬ. Программная реализация алгоритма =

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

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

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

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

Исследование масштабируемости параллельной реализации алгоритма COBWEB проводилось на компьютере с процессором Intel(R) Core(TM) i7-5960X @ 4.30GHz, который поддерживает до 12ти потоков при наличии 6 физических ядер. Была взята реализация алгоритма COBWEB на Python из библиотки Concept Formation<ref name="gh_cf" /> и распараллелена с использованием средств Python multiprocessing<ref>https://docs.python.org/3.5/library/multiprocessing.html — библиотека multiprocessing для распараллеливания программ на Python</ref>.

Для исследования масштабируемости проводилось множество запусков программы с разным количеством объектов для кластеризации <math>N</math>, а также с различным числом процессоров. Фиксировались время работы и количество произведенных итераций алгоритма.

Параметры запусков для экспериментальной оценки:
* Количество объектов для кластеризации <math>N</math>: 1000, 2000, 3000, 4000, 5000, 6000, 7000, 8000, 9000
* Количество процессоров <math>p</math>: 1, 2, 3, 4, 5, 6
* Версия Python: 3.5

Данные выбирались из стандартной библиотеки тестовых данных Библиоткеи Concept Formation (mushrooms).

Для заданной конфигурации эксперимента и полученным результатам [[Глоссарий#Производительность|производительность]] и эффективность реализации расчитывались по формулам:

<math>Perf = \frac{N_{op}}{t}\ \ (FLOPS),</math>,
где <math>N_{op}</math> — точное число операций с плавающей точкой (операции с памятью, а также целочисленные операции не учитывались), вычисленное в соответствие с разделом [[#Последовательная сложность алгоритма| "Последовательная сложность алгоритма"]];

<math>Efficiency = \frac{100 * Performance}{Perf_{Peak}^{p}}\ \ (%),</math>,
где <math>Perf_{Peak}^{p}</math> – пиковая производительность суперкомпьютера при <math>p</math> процессорах, вычисленная согласно спецификациям Intel® Core i7® X5960<ref>"http://ark.intel.com/ru/products/82930/Intel-Core-i7-5960X-Processor-Extreme-Edition-20M-Cache-up-to-3_50-GHz"</ref>.

Графики зависимости производительности и эффективности параллельной реализации COBWEB от числа векторов для кластеризации (<math>N</math>) и числа процессоров (<math>p</math>) представлены ниже.

[[file:Cobwebtime.png|thumb|center|640px|Рис. 2 Время работы алгоритма COBWEB в зависимости от числа процессов и размера задачи]]
[[file:Cobwebeff.png|thumb|center|640px|Рис. 3 Эффективность алгоритма COBWEB в зависимости от числа процессов и размера задачи]]

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

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

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

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

Существуют следующие реализации алгоритма COBWEB:
* [https://github.com/cmaclell/concept_formation/ Concept Formation]<ref name="gh_cf">https://github.com/cmaclell/concept_formation/ — библиотека, содержащая реализации алгоритмов COBWEB и COBWEB/3 для языка Python</ref> библиотека, содержащая реализации алгоритмов COBWEB и COBWEB/3 для языка Python.
* [http://www.cs.waikato.ac.nz/~ml/weka Weka]<ref>http://www.cs.waikato.ac.nz/~ml/weka — библиотека и инструмент для анализа данных на языке Java</ref> библиотека и инструмент для анализа данных на языке Java.
* [http://java-ml.sourceforge.net/ Java-ML] <ref>http://java-ml.sourceforge.net/ — библиотека машинного обучения на языке Java</ref> библиотека машинного обучения на языке Java.

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

= Литература =
<references>
<ref name="wiki">https://en.wikipedia.org/wiki/Cobweb_(clustering) — описание алгоритма на Википедии (Eng)</ref>
<ref name="habr">https://habrahabr.ru/post/164417/ — сравнение алгоритма COBWEB с другими алгоритмами кластеризации</ref>
<ref name="shit">http://bourabai.ru/tpoi/analysis6.htm — подробное описание алгоритма COBWEB</ref>
<ref name="paper">http://www.cl.cam.ac.uk/~av308/cobweb.pdf — статья, в которой алгоритм COBWEB был впервые представлем</ref>
</references>

Участник:Казаков Артем/Алгоритм концептуальной кластеризации COBWEB

2016-12-12T14:27:00Z

Dexter:

{Assignment|Преподаватель 1|Dexter}}
{{Assignment|ASA}}

{{algorithm
| name = Алгоритм концептуальной кластеризации COBWEB
| serial_complexity = <math>O(N*logN*B^{2}AV)</math>
| parallel_complexity = <math>O(N*logN*log(BAV))</math>
}}

Автор статьи: [[Участник: Казаков Артем|Артем Казаков]] (группа 624)

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

== Общее описание алгоритма ==
Алгоритм '''COBWEB'''<ref name="wiki" /><ref name="paper" /> — классический метод инкрементальной концептуальной кластеризации. Он создаёт иерархическую кластеризацию в виде дерева классификации: каждый узел этого дерева ссылается на концепт (концепт — описание группы объектов через определенный набор пар аттрибут-значение) и содержит вероятностное описание этого концепта, которое включает в себя вероятность принадлежности концепта к данному узлу.<ref name="habr" />

Узлы, находящейся на определённом уровне дерева классификации, называют срезом. Алгоритм использует для построения дерева классификации эвристическую меру оценки, называемую полезностью категории — прирост ожидаемого числа корректных предположений о значениях атрибутов при знании об их принадлежности к определённой категории относительно ожидаемого числа корректных предположений о значениях атрибутов без этого знания. Чтобы встроить новый объект в дерево классификации, алгоритм '''COBWEB''' итеративно проходит всё дерево в поисках «лучшего» узла, к которому отнести этот объект. Выбор узла осуществляется на основе помещения объекта в каждый узел и вычисления полезности категории получившегося среза. Также вычисляется полезность категории для случая, когда объект относится к вновь создаваемому узлу. В итоге объект относится к тому узлу, для которого полезность категории наибольшая.

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

== Математическое описание алгоритма ==
Обозначим:
* <math>\{ A_{1}, A_{2}, ... \}</math> — множество свойств кластеризуемых объектов
* <math>\{ u_{1j}, u_{2j}, ... \}</math> — возможнные значения свойства <math>A_{j}</math>
* <math>\{ C_{1}, C_{2}, ... \}</math> — множество категорий

<math>P(A_j = u_{ij} | C_k)</math> — это условная вероятность, с которой свойство <math>A_{j}</math>, принимает значение <math>u_{ij}</math>, если объект относится к категории <math>C_{k}</math>. Для каждой категории в иерархии определены вероятности вхождения всех значений каждого свойства. При предъявлении нового экземпляра система '''COBWEB''' оценивает качество отнесения этого примера к существующей категории и модификации иерархии категорий в соответствии с новым представителем. Критерием оценки качества классификации является полезность категории (''category utility'').

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

<math>CU = \sum_{k} \sum_{i} \sum_{j} P(A_j = u_{ij}|C_k) P(C_k|A_j = u_{ij}) P(A_j = u_{ij})</math><ref name="shit" />

Значения суммируются по всем категориям <math>C_k</math>, всем свойствам <math>A_j</math> и всем значениям свойств <math>u_{ij}</math>. Значение <math>P(A_j = u_{ij} | C_k)</math> называется предсказуемостью (predictability). Это вероятность того, что объект, для которого свойство <math>A_j</math> принимает значение <math>u_{ij}</math>, относится к категории <math>C_k</math>. Чем выше это значение, тем вероятнее, что свойства двух объектов, отнесенных к одной категории, имеют одинаковые значения. Величина <math>P(C_k | A = u_{ij})</math> называется предиктивностью (predictiveness). Это вероятность того, что для объектов из категории <math>C_k</math> свойство <math>A_j</math> принимает значение <math>u_{ij}</math>. Чем больше эта величина, тем менее вероятно, что для объектов, не относящихся к данной категории, это свойство будет принимать указанное значение. Значение <math>P(A = u_{ij})</math> — это весовой коэффициент, усиливающий влияние наиболее распространенных свойств. Благодаря совместному учету этих значений высокая полезность категории означает высокую вероятность того, что объекты из одной категории обладают одинаковыми свойствами, и низкую вероятность наличия этих свойств у объектов из других категорий.

== Вычислительное ядро алгоритма ==
Основное время работы алгоритма приходится на вычисление полезности категории.

Обозначим:

* <math>B</math> — среднее число потомков узлов в дереве классификации
* <math>N</math> — число объектов для классификации
* <math>A</math> — числа свойств у классифицируемых объектов
* <math>V</math> — среднее число значений, которые могут принимать свойства

На каждом шаге алгоритма (всего <math>N</math> производится спуск по дереву (<math>O(log_{B}N)</math>). На каждой итерации спуска производится <math>O(B)</math> вычислений полезности категории <math>CU</math>, вычисление каждой из которых имеет сложность <math>O(BAV)</math>.

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

== Макроструктура алгоритма ==
В алгоритме '''COBWEB''' реализован метод поиска экстремума в пространстве возможных кластеров с использованием критерия полезности категорий для оценки и выбора возможных способов категоризации.

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

== Схема реализации последовательного алгоритма ==
Алгоритм повторяется для каждого нового объекта. В данном алгоритме происходит спуск по дереву и на каждом шаге спуска выбирается одно из действий описанных в п. 1.4.

<pre>cobweb(Node, Instance)
Begin
if узел Node - это лист, then
begin
создать два дочерних узла L1 и L2 для узла Node;
задать для узла L1 те же вероятности, что и для узла Node;
инициализировать вероятности для узла L2 соответствующими значениями объекта Instance;
добавить Instance к Node, обновив вероятности для узла Node ;
end
else
begin
добавить Instance к Node, обновив вероятности для узла Node;
для каждого дочернего узла С узла Node вычислить полезность категории при отнесении экземпляра Instance к категории С;
пусть S1 - значение полезности для наилучшей классификации C1;
пусть S2 - значение для второй наилучшей классификации C2;
пусть S3 - значение полезности для отнесения экземпляра к новой категории;
пусть S4 - значение для слияния C1 и C2 в одну категорию;
пусть S5 - значение для разделения C1 (замены дочерними категориями);
end
if S1 - максимальное значение CU, then
cobweb(C1, Instance) %отнести экземпляр к C1
else
if S3 - максимальное значение CU, then
инициализировать вероятности для новой категории Cm значениями Instance
else
if S4 - максимальное значение CU, then
begin
пусть Cm - результат слияния C1 и C2;
cobweb(Cm, Instance);
end
else
if S5 - максимальное значение CU, then
begin
разделить C1; % Cm - новая категория
cobweb(Cm, Instance)
end;
end</pre>

== Последовательная сложность алгоритма ==
Последовательная сложность алгоритма равна <math>O(N*log_{B}N*B^{2}AV)</math>

где:
* <math>B</math> — среднее число потомков узлов в дереве классификации
* <math>N</math> — число объектов для классификации
* <math>A</math> — числа свойств у классифицируемых объектов
* <math>V</math> — среднее число значений, которые могут принимать свойства

Обоснование сложности приводится в п. 1.3.

== Информационный граф ==
[[file:Cobweb-flow-2.png|thumb|center|750px|Рис. 1 Информационный граф алгоритма COBWEB]]

<math>N_0</math> — корневой узел

<math>N_{11}, N_{12}, ..., N_{1L}</math> — узлы первого уровня

<math>N_{21}, N_{22}, ..., N_{2L}</math> — узлы второго уровня

<math>N_{B1}, N_{B2}, ..., N_{BL}</math> — узлы последнего уровня

<math>C_1, C_2, ..., C_L</math> — шаги спуска по дереву

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

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

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

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

* распараллеливание процесса вычисления совокупности функций полезности
* распараллеливание вычисления каждой конкретной функции полезности

Оба данных подхода к распараллеливанию могут быть использованы вместе.

* При неограниченном ресурсе параллелизма, вычисление функции полезности может быть произведено за <math>O(log(BAV))</math> через независимое вычисление каждой её составной части (за <math>O(1)</math>) и последующую их параллельную редукцию за <math>O(log(q))</math>, где <math>q=BAV</math> — количество составных частей функции полезности.
* Вычисление совокупности функций полезности (которых <math>O(B)</math>) также может быть распараллелено c последующей параллельной редукцией за <math>O(log(B))</math> и итоговой параллельной сложностью <math>O(log(BAV)+log(B))=log(BAV))</math> (при неограниченном ресурсе параллелизма).
* Продвижение объектов по дереву может не может быть распараллелено, поскольку входные данные для каждой очередной итерации зависят от результата выполнения предыдущей. Всего за время работы алгоритма выполняется <math>O(N*logN)</math> операций продвижения по дереву.

Таким образом, итоговая параллельная сложность алгоритма равна <math>N*logN*log(BAV)</math>.

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

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

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

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

Оценка вычислительной мощности алгоритма составляет <math>O(N * B * V * (A + logN))</math>.

= ЧАСТЬ. Программная реализация алгоритма =

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

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

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

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

Исследование масштабируемости параллельной реализации алгоритма COBWEB проводилось на компьютере с процессором Intel(R) Core(TM) i7-5960X @ 4.30GHz, который поддерживает до 12ти потоков при наличии 6 физических ядер. Была взята реализация алгоритма COBWEB на Python из библиотки Concept Formation<ref name="gh_cf" /> и распараллелена с использованием средств Python multiprocessing<ref>https://docs.python.org/3.5/library/multiprocessing.html — библиотека multiprocessing для распараллеливания программ на Python</ref>.

Для исследования масштабируемости проводилось множество запусков программы с разным количеством объектов для кластеризации <math>N</math>, а также с различным числом процессоров. Фиксировались время работы и количество произведенных итераций алгоритма.

Параметры запусков для экспериментальной оценки:
* Количество объектов для кластеризации <math>N</math>: 1000, 2000, 3000, 4000, 5000, 6000, 7000, 8000, 9000
* Количество процессоров <math>p</math>: 1, 2, 3, 4, 5, 6
* Версия Python: 3.5

Данные выбирались из стандартной библиотеки тестовых данных Библиоткеи Concept Formation (mushrooms).

Для заданной конфигурации эксперимента и полученным результатам [[Глоссарий#Производительность|производительность]] и эффективность реализации расчитывались по формулам:

<math>Perf = \frac{N_{op}}{t}\ \ (FLOPS),</math>,
где <math>N_{op}</math> — точное число операций с плавающей точкой (операции с памятью, а также целочисленные операции не учитывались), вычисленное в соответствие с разделом [[#Последовательная сложность алгоритма| "Последовательная сложность алгоритма"]];

<math>Efficiency = \frac{100 * Performance}{Perf_{Peak}^{p}}\ \ (%),</math>,
где <math>Perf_{Peak}^{p}</math> – пиковая производительность суперкомпьютера при <math>p</math> процессорах, вычисленная согласно спецификациям Intel® Core i7® X5960<ref>"http://ark.intel.com/ru/products/82930/Intel-Core-i7-5960X-Processor-Extreme-Edition-20M-Cache-up-to-3_50-GHz"</ref>.

Графики зависимости производительности и эффективности параллельной реализации COBWEB от числа векторов для кластеризации (<math>N</math>) и числа процессоров (<math>p</math>) представлены ниже.

[[file:Cobwebtime.png|thumb|center|640px|Рис. 2 Время работы алгоритма COBWEB в зависимости от числа процессов и размера задачи]]
[[file:Cobwebeff.png|thumb|center|640px|Рис. 3 Эффективность алгоритма COBWEB в зависимости от числа процессов и размера задачи]]

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

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

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

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

Существуют следующие реализации алгоритма COBWEB:
* [https://github.com/cmaclell/concept_formation/ Concept Formation]<ref name="gh_cf">https://github.com/cmaclell/concept_formation/ — библиотека, содержащая реализации алгоритмов COBWEB и COBWEB/3 для языка Python</ref> библиотека, содержащая реализации алгоритмов COBWEB и COBWEB/3 для языка Python.
* [http://www.cs.waikato.ac.nz/~ml/weka Weka]<ref>http://www.cs.waikato.ac.nz/~ml/weka — библиотека и инструмент для анализа данных на языке Java</ref> библиотека и инструмент для анализа данных на языке Java.
* [http://java-ml.sourceforge.net/ Java-ML] <ref>http://java-ml.sourceforge.net/ — библиотека машинного обучения на языке Java</ref> библиотека машинного обучения на языке Java.

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

= Литература =
<references>
<ref name="wiki">https://en.wikipedia.org/wiki/Cobweb_(clustering) — описание алгоритма на Википедии (Eng)</ref>
<ref name="habr">https://habrahabr.ru/post/164417/ — сравнение алгоритма COBWEB с другими алгоритмами кластеризации</ref>
<ref name="shit">http://bourabai.ru/tpoi/analysis6.htm — подробное описание алгоритма COBWEB</ref>
<ref name="paper">http://www.cl.cam.ac.uk/~av308/cobweb.pdf — статья, в которой алгоритм COBWEB был впервые представлем</ref>
</references>

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

2016-12-08T12:24:23Z

Dexter: /* Новые замечания */

== Новые замечания ==
П 1.5 Перечитайте фразу "Алгоритм извлекает все точки в X, которые являются плотность достижима из x и добавляет их в кластер C" - явно что-то не так с грамматикой. Почему x и X в начале этого пункта набраны в виде формул, а затем вдруг стали обычными буквами? Лучше везде использовать формулы

== Замечания к оформлению статьи: ==

0. Укажите свои ФИО, номер группы.

1. В начале статьи должна быть таблица со следующей информацией (Последовательная сложность, Объём входных данных, Объём выходных данных, Высота ярусно-параллельной формы, Ширина ярусно-параллельной формы).

2. В пункте 1.7 должен быть понятный и наглядный рисунок информационного графа ('''ациклический''' граф, вершины - операции, дуги - информационные зависимости). (см. пример: https://algowiki-project.org/ru/%D0%A0%D0%B0%D0%B7%D0%BB%D0%BE%D0%B6%D0%B5%D0%BD%D0%B8%D0%B5_%D0%A5%D0%BE%D0%BB%D0%B5%D1%86%D0%BA%D0%BE%D0%B3%D0%BE_(%D0%BC%D0%B5%D1%82%D0%BE%D0%B4_%D0%BA%D0%B2%D0%B0%D0%B4%D1%80%D0%B0%D1%82%D0%BD%D0%BE%D0%B3%D0%BE_%D0%BA%D0%BE%D1%80%D0%BD%D1%8F)

3. Вычислительная мощность не приведена. (см. пример: https://algowiki-project.org/ru/%D0%A0%D0%B0%D0%B7%D0%BB%D0%BE%D0%B6%D0%B5%D0%BD%D0%B8%D0%B5_%D0%A5%D0%BE%D0%BB%D0%B5%D1%86%D0%BA%D0%BE%D0%B3%D0%BE_(%D0%BC%D0%B5%D1%82%D0%BE%D0%B4_%D0%BA%D0%B2%D0%B0%D0%B4%D1%80%D0%B0%D1%82%D0%BD%D0%BE%D0%B3%D0%BE_%D0%BA%D0%BE%D1%80%D0%BD%D1%8F)

4. В пункте 1.1 не приведено ни одного свойства алгоритма.

5. Пункт 1.3 стоит расписать подробнее. Например, привести основные операции, которые применяются выч. ядре алгоритма. Описать, почему как использование специального вида деревьев улучшает алгоритм.

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

2016-12-08T12:23:57Z

Dexter:

== Новые замечания ==
П 1.5 Перечитайте фразу "Алгоритм извлекает все точки в X, которые являются плотность достижима из x и добавляет их в кластер C" - явно что-то не так с грамматикой. Почему x и X в начале этого пункта набраны в виде формул, а затем вдруг стали обычными буквами? Лучше везде использовать формулы

Замечания к оформлению статьи:

0. Укажите свои ФИО, номер группы.

1. В начале статьи должна быть таблица со следующей информацией (Последовательная сложность, Объём входных данных, Объём выходных данных, Высота ярусно-параллельной формы, Ширина ярусно-параллельной формы).

2. В пункте 1.7 должен быть понятный и наглядный рисунок информационного графа ('''ациклический''' граф, вершины - операции, дуги - информационные зависимости). (см. пример: https://algowiki-project.org/ru/%D0%A0%D0%B0%D0%B7%D0%BB%D0%BE%D0%B6%D0%B5%D0%BD%D0%B8%D0%B5_%D0%A5%D0%BE%D0%BB%D0%B5%D1%86%D0%BA%D0%BE%D0%B3%D0%BE_(%D0%BC%D0%B5%D1%82%D0%BE%D0%B4_%D0%BA%D0%B2%D0%B0%D0%B4%D1%80%D0%B0%D1%82%D0%BD%D0%BE%D0%B3%D0%BE_%D0%BA%D0%BE%D1%80%D0%BD%D1%8F)

3. Вычислительная мощность не приведена. (см. пример: https://algowiki-project.org/ru/%D0%A0%D0%B0%D0%B7%D0%BB%D0%BE%D0%B6%D0%B5%D0%BD%D0%B8%D0%B5_%D0%A5%D0%BE%D0%BB%D0%B5%D1%86%D0%BA%D0%BE%D0%B3%D0%BE_(%D0%BC%D0%B5%D1%82%D0%BE%D0%B4_%D0%BA%D0%B2%D0%B0%D0%B4%D1%80%D0%B0%D1%82%D0%BD%D0%BE%D0%B3%D0%BE_%D0%BA%D0%BE%D1%80%D0%BD%D1%8F)

4. В пункте 1.1 не приведено ни одного свойства алгоритма.

5. Пункт 1.3 стоит расписать подробнее. Например, привести основные операции, которые применяются выч. ядре алгоритма. Описать, почему как использование специального вида деревьев улучшает алгоритм.

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

2016-12-08T12:09:22Z

Dexter:

== Новые замечания ==
1) п1.2.2 Что такое n с двойной индексацией?

2) Общие слова о модернизациях - плохой заголовок, переформулируйте

3) п1.5 очень плохое выравнивание в псевдокоде

4) Почему поэлементное умножение вектора на вектор обозначается так же как поэлементное деления вектора на вектор?

== Замечания к [[ЕМ-алгоритм_(Тематическое_моделирование)]] ==

1) следует переоформить пункт 1.5 - или использовать явный псевдокод с отступами в теге <nowiki><source lang="..."></nowiki> или использовать математические формулы, но описывать структуру текстом. Текущий вариант плохо воспринимается.

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

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

2016-12-02T19:28:32Z

Dexter:

== Статья [[Участник:Казаков Артем/Алгоритм концептуальной кластеризации COBWEB]] ==
=== Замечания второго рецензента ===
* В тексте нет ссылок на источники
* Сам список оформлен плохо - только гиперссылки. Кроме ссылок нужны названия источников
* п 1.1 - поясните, что такое концепт
* п 1.2 - что такое A и B?
* п 1.3 - список как-то неудачен - соседние пункты - это куски фраз
=== Замечания по тексту ===
* В разделе 1.5 кроме псевдокода нужны также текстовые пояснения. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 15:46, 28 ноября 2016 (MSK)
* Граф, приведённый в разделе 1.7, не является информационным графом (ациклический граф, вершины - операции, дуги - информационные зависимости). [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 15:46, 28 ноября 2016 (MSK)
** Замечание не исправлено. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 13:17, 30 ноября 2016 (MSK)
*** Исправил [[Участник:Казаков Артем|Казаков Артем]] ([[Обсуждение участника:Казаков Артем|обсуждение]]) 02:17, 1 декабря 2016 (MSK)
* В разделе 1.9 должны быть оценки объёмов входных и выходных данных. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 15:46, 28 ноября 2016 (MSK)
* В разделе 1.10 должна быть оценка вычислительной мощности алгоритма. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 15:46, 28 ноября 2016 (MSK)
* В разделе 2.4 не приведены все параметры запуска теста - какой компилятор, с какими опциями использовался, какие версии библиотек, на каких узлах проводился запуск и т.д. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 15:46, 28 ноября 2016 (MSK)
** Замечание не исправлено. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 13:17, 30 ноября 2016 (MSK)
*** Понятие компилятора и его опций неприменимо для языка Python. Версия интерпретатора была указана (Python 3.5), дополнительных библиотек не использовалось, способ запуска также указан (модель процессора, количество потоков). [[Участник:Казаков Артем|Казаков Артем]] ([[Обсуждение участника:Казаков Артем|обсуждение]]) 02:17, 1 декабря 2016 (MSK)
* В разделе 2.4 не приведена использованная в экспериментах реализация алгоритма. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 15:46, 28 ноября 2016 (MSK)
* Из графиков в разделе 2.4 следует сделать выводы о масштабируемости реализации. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 15:46, 28 ноября 2016 (MSK)
* Рисунки в статье не пронумерованы. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 15:46, 28 ноября 2016 (MSK)
* В список литературы следует включить ссылки по описываемому алгоритму. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 15:46, 28 ноября 2016 (MSK)

=== Re: Замечания по тексту ===
Все исправил. [[Участник:Казаков Артем|Казаков Артем]] ([[Обсуждение участника:Казаков Артем|обсуждение]]) 04:57, 30 ноября 2016 (MSK)

Участник:Elena777mc/Плотностный алгоритм кластеризации DBSCAN

2016-11-28T14:59:16Z

Dexter:

{{Assignment|Преподаватель 1|Dexter}}
{{Assignment|Sleo}}

{{algorithm
| name = Плотностный алгоритм кластеризации DBSCAN
| serial_complexity = <math>O(n \log n)</math>
| pf_height = <math>O(|X| \log |X|)</math>
| pf_width = <math>O(m)</math>
| input_data = <math>n</math>
| output_data = <math>n</math>
}}

Основные авторы описания: [[Участник:Elena777mc|Малахова Е.С.]] (1.2, 1.4-1.8, 2.4, 2.7), [[Участник:Жаннат_Сагиолданова|Сагиолданова Ж.]] (1.1-1.3, 1.9-1.10, 3)

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

== Общее описание алгоритма ==
Кластеризация – это процесс разбиения множества с <math>N</math> элементами <math>x_1, x_2, ... , x_n (x_n</math> имеет размерность <math>m</math>) на <math>K</math> кластеров, так, чтобы в каждом кластере все элементы были схожи
в каком-то смысле. <math>x_i</math> могут быть числовыми, категориальными или смешанными данными. В плотностных методах кластеры рассматриваются как регионы пространства данных с высокой плотностью объектов, которые разделены регионами с низкой плотностью объектов.

Алгоритм DBSCAN (Density Based Spatial Clustering of Applications with Noise) <ref>A density-based algorithm for discovering clusters in large spatial database / M. Ester, H.-P. Kriegel,
J. Sander, X. Xu // Proc. 1996 Intern. Conf. on Knowledge Discovery and Data Mining. – 1996. – P. 226 –
231.</ref> –плотностной алгоритм для кластеризации пространственных данных с присутствием шума, был предложен Мартином Эстер, Гансом-Питером Кригель и их коллегами в 1996 году как решение проблемы разбиения (изначально пространственных) данных на кластеры произвольной формы.

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

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

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

[[File:Dbscan_picture.png|thumb|right|500px| Рис. 1. Пример ядровых, граничных и шумовых точек алгоритма. Точка A - ядровая, точки B и С - граничные, N - шум. В данном примере MinPts = 4, Eps равен радиусу окружности <ref>https://upload.wikimedia.org/wikipedia/commons/thumb/a/af/DBSCAN-Illustration.svg/400px-DBSCAN-Illustration.svg.png</ref>]]

Исходные данные: объекты, которые нужно кластеризовать, параметры <math>MinPts, \ \varepsilon</math> . Между объектами можно считать расстояния.

Вычисляемые данные: разбиение объектов по кластерам. Количество кластеров зависит от исходных данных. <ref>"Xu, X. A fast parallel clustering algorithm for large spatial databases / X. Xu, M. Ester, H.-P. Kriegel // Proc. 1999 Intern. Conf. on Knowledge Discovery and Data Mining. – 1999. – Vol. 3, is. 3. – P. 263 – 290.</ref>

Для построения оценки плотности, на основе соседства точек вводятся понятия
достижимости и связности. Под <math>\varepsilon </math> -соседями точки <math>x \in X</math> понимается множество точек, расстояние до которых не превышает <math>\varepsilon </math>, т. е.
<math>N_\varepsilon (x) = \{y \in X | D(x, y) \le \varepsilon\}</math>.
Тогда точка <math>y</math> достижима из точки <math>x</math>, если существует последовательность точек <math>x^{(1)}=x, x^{(2)},... , x^{(p-1)}, x^{(p)}=y</math>, для которой выполнено:
:<math>
\begin{align}
x^{(i+1)} \in N_\varepsilon (x^{(i)}), i=1,... ,p-1 \\
\mid N_\varepsilon (x^{(i)}) \mid \ge MinPts, i=1,... ,p-1
\end{align}
</math>

Здесь значение <math>MinPts</math> задаётся пользователем и регулирует порог «шума». Согласно второму условию, у точек, находящихся внутри кластера, должно быть не менее <math>MinPts \ \varepsilon</math> -соседей. Такие точки называются «ядрами». Остальные точки разделяются на граничные (имеющие менее <math>MinPts \ \varepsilon </math> -cоседей, но достижимые из какого-либо «ядра») и шумовые. Две точки связны, если существует «ядро», из которого они обе достижимы.
При такой постановке задачи, под кластером понимается максимальное связное подмножество множества <math>X</math> . Точки, не попавшие в какой-либо кластер (не принадлежащие <math>\varepsilon</math> -окрестности какого-либо «ядра»), относятся к классу «шум».

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

Вычислительным ядром алгоритма является нахождение <math>\varepsilon</math>-соседей каждого объекта входного множества <math>X</math>. На эту часть алгоритма приходится основное время работы алгоритма, так как требуется найти всех соседей для каждого объекта заданного множества. Основные операции, которые применяются в вычислительном ядре алгоритма: нахождение расстояние между объектами и сравнение расстояния с порогом для определения того, являются ли данные объекты <math>\varepsilon</math>-соседями.

== Макроструктура алгоритма ==
Алгоритм DBSCAN использует пространственную структуру данных для определения соседних объектов. Такие структуры данных позволяют найти все объекты в пределах определенного расстояния от текущего объекта. Сложность построения таких структур <math>O(n \log n)</math>, и использование такой структуры не увеличит сложность всего алгоритма (если сложность самого алгоритма <math>O(n \log n)</math>). Также для построения таких деревьев нужно уметь находить расстояния между объектами <math>\rho(u,v)</math>, это расстояние можно вводить разными способами. Например, если <math>\rho(u,v)</math> - метрика в евклидовом пространстве, <math>u=(u_1,...,u_n)</math> и <math>(v_1,...,v_n)</math>, то расстояние вычисляется следующим образом: <math>\rho(u,v)=\sqrt{(u_1-v_1)^2+(u_2-v_2)^2+...+(u_n-v_n)^2} = \sqrt{\sum_{k=1}^n(u_k-v_k)^2}</math>

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

// Основная функция, которая реализует алгоритм кластеризации
<math>DBSCAN(X, \varepsilon, MinPts)</math>
//Изначально все объекты в <math>X</math>не кластеризованы
<math>FORALL</math> objects <math>x</math> in <math>X\ DO</math>
<math>IF\ x</math> is unclassified
call function <math>expand\_cluster</math> to construct a cluster wrt. <math>\varepsilon</math> and <math>MinPts</math> containing <math>x</math>

// Функция, которая строит кластер на основе одной точки
<math>FUNCTION\ expand\_cluster(x,X,\varepsilon, MinPts):</math>
<math>retrive\_\varepsilon neighborhood(x, \varepsilon)</math>;
<math>IF \mid N_{\varepsilon}(x) \mid < MinPts</math> //т.е. <math>x</math> - объект, не являющийся ядром
mark <math>x</math> as <math>noise</math> and <math>RETURN</math>;
<math>ELSE</math>//т.е. <math>x</math> - объект, являющийся ядром
select a new cluster-id and mark all objects in <math>N_{\varepsilon}(x)</math> with this current <math>cluster-id</math>;
push all objects from <math>N_{\varepsilon}(x)</math>\<math>(x)</math> onto the stack seeds;
<math>WHILE\ NOT</math> seeds.empty() <math>DO</math>
<math>currentObject</math> := seeds.top();
seeds.pop();
<math>retrive\_\varepsilon neighborhood(currentObject, \varepsilon)</math>;
<math>IF \mid N_{\varepsilon}(currentObjects) \mid \ge MinPts</math>
select all objects in <math>N_{\varepsilon}(currentObject)</math> not yet classified or marked as <math>noise</math>,
push the unclassified objects onto seeds and mark all of these objects with current <math>cluster-id</math>;
<math>RETURN</math>

// Функция, для определения <math>\varepsilon</math>-соседей для объекта
<math>FUNCTION\ retrive\_\varepsilon neighborhood(x, \varepsilon)</math> //функция возвращает соседей на основе пространственной структуры данных
return <math>\{ x' \ | \ \forall x' \in X: \rho(x, x') < \varepsilon \}</math>

== Последовательная сложность алгоритма ==
Для того, чтобы алгоритм мог кластеризовать все объекты, необходимо пройти по каждому из них хотя бы один раз. Если использовать R*-дерево или kd-дерево для определения соседних объектов со сложностью <math>O(\log n)</math>, то сложность алгоритма <math>O(n \log n)</math>. Если не использовать эти структуры, то в худшем случае алгоритм будет иметь сложность <math>O(n^2)</math>, так как придется считать полную матрицу расстояний между объектами.

== Информационный граф ==
В настоящем алгоритме осуществляется параллелизм по данным. Ниже представлена общая структура данного алгоритма.
[[File:Dbscan_schema.jpg|1000px|thumb|center|Рис.1. Общая информационная структура алгоритма]]
Разбиение данных происходит с помощью пространственной структуры данных (R*-дерево, kd-дерево), которая разбивает все множество объектов <math>X</math> на <math>m</math> частей: <math>X_1,X_2,...,X_m</math>.
На каждой части объектов применяется алгоритм PDBSCAN. PDBSCAN - это последовательный алгоритм DBSCAN, применяемый только к одной части объектов, и для каждой из этих частей он определяет кандидатов на слияние. PDBSCAN использует пространственную структуру, которая распределяется вместе с данными.
Если для ядрового объекта части <math>X_i</math> в <math>\varepsilon</math>-окрестности находится объект из другой части <math>X_j</math>, то такие объекты становятся кандидатами на слияние.

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

[[File:dbscan_clusters_partitions.png|500px|thumb|center|Рис.2. Пример разбиения объектов на части на основе пространственной структуры. Каждый прямоугольник соответствует части данных, каждая из которых подается на вход алгоритму PDBSCAN <ref>https://github.com/bwoneill/pypardis/blob/master/plots/median_search_split/clusters_partitions.png</ref>]]

== Ресурс параллелизма алгоритма ==
Как видно из общей структуры графа алгоритма, ширина ярусно-параллельной формы алгоритма <math>O(m)</math>, где m - количество частей, на которые разбиваются все входное множество объектов <math>X</math>. Высотой ярусно-параллельной формы алгоритма является <math>O(|X| \log |X|)</math>, где <math>\mid X \mid</math> - максимальное количество среди числа объектов в каждой части разбиения. Именно такую сложность имеет алгоритм PDBSCAN, применяемый к каждой отдельной части разбиения.

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

'''Входные данные''': множество точек X из n-мерного пространства, на котором определена функция расстояния D. В наиболее распространенном случае пространственной кластеризации используется Евлидова метрика между векторами из <math>{R}^n</math>.

'''Объём входных данных''': n (размерность входящего множества)

'''Выходные данные''': размеченное множество точек X, в котором каждой точке соответствует номер ее кластера. Обычно каждой точке из X сопоставляется ее номер, а на выходе алгоритм дает отображение номеров точек в номера соответствующих им кластеров, например в виде вектора размера |X|

'''Объём выходных данных''': n (размерность выходящего множества)

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

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

''' Преимущества алгоритма '''

* алгоритм может обрабатывать большой объем данных и не зависит от порядка ввода данных;
* может определять кластера произвольной формы;
* параллельная реализация сбалансирована по количеству и виду производимых операций (вычисление расстояния, сравнение с <math>\varepsilon</math>);
* не требуется задание числа кластеров;
* может выделять кластеры в присутствии «шума»и выбросов <ref>АЛГОРИТМЫ КЛАСТЕРИЗАЦИИ В ЗАДАЧАХ СЕГМЕНТАЦИИ
СПУТНИКОВЫХ ИЗОБРАЖЕНИЙ/ И. А. Пестунов, Ю. Н. Синявский// Вестник Кемеровского государственного университета. – 2012. – P. 263–
299.</ref>;
* число итераций определяется заранее.

''' Недостатки алгоритма '''

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

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

== Особенности реализации последовательного алгоритма ==
== Локальность данных и вычислений ==
== Возможные способы и особенности параллельной реализации алгоритма ==
== Масштабируемость алгоритма и его реализации ==
Было проведено исследование масштабируемости параллельной реализации алгоритма DBSCAN . Исследование проводилось на суперкомпьютере "Ломоносов" [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета]. Исследовалась параллельная реализация алгоритма, написанная с использованием стандарта MPI. Распараллеливание проводилось по числу входных объектов, поэтому исследование масштабируемости проводилось для числа входных объектов. Алгоритм тестировался на известном датасете для кластеризации: [https://archive.ics.uci.edu/ml/datasets/Individual+household+electric+power+consumption Machine Learning Repository]

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

* число процессоров [1 : 128] с шагом по степеням двойки;
* число входных объектов [1000 : 40000].

На следующих рисунках приведены графики производительности и эффективности распараллеливания алгоритма DBSCAN в зависимости от изменяемых параметров запуска.
[[File:Dbscan_perfomance.png|800px|thumb|center|Рис.1. Изменение производительности в зависимости от числа процессов и числа входных данных]]
[[File:Dbscan_efficiency.png|800px|thumb|center|Рис.2. Изменение эффективности распараллеливания в зависимости от числа процессов и числа входных данных]]

Построим оценки масштабируемости протестированной параллельной реализации алгоритма DBSCAN:

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

'''По размеру задачи''' - При увеличении размерности системы при фиксированном количестве процессов на области изменений значений параметров наблюдается увеличение эффективности.

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

[https://github.com/elena777mc/dbscan/tree/master Исследованная параллельная реализация на языке C++]

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

* [http://scikit-learn.org/stable/modules/generated/sklearn.cluster.DBSCAN.html Scikit learn (Python, последовательная реализация)]
* [http://cucis.ece.northwestern.edu/projects/Clustering/download_code_dbscan.html Northwestern University (C++, параллельная реализация kd-tree)]
* [https://github.com/ContinuumIO/parallel_dbscan github/ContinuumIO (Python, параллельная реализация)]
* [https://github.com/propanoid/DBSCAN github/propanoid (C++, последовательная реализация VP tree)]
* [https://github.com/dparks1134/DBSCAN github/dparks1134 (С++, последовательная реализация)]
* [https://github.com/ahbarnett/validspike/tree/master/contrib/dbscan_patwary Disjoint-Set Data Structure based Parallel DBSCAN (C++ параллельная реализация kd-tree)]
* [https://github.com/bwoneill/pypardis github/bwoneill (Spark/Python параллельная реализация kd-tree)]
* [https://github.com/alitouka/spark_dbscan github/alitouka (Spark/Scala параллельная реализация)]
* [https://github.com/mhahsler/dbscan CRAN (R, последовательная реализация)]

= Литература =
<references \>
<references \>[https://pdfs.semanticscholar.org/a3f8/a3948e5999def4a0819d0dbaef2ae05e1599.pdf (A Fast Parallel Clustering Algorithm for Large Spatial Databases, JOCHEN JAGER, HANS-PETER KRIEGEL)]
<references \>[http://cyberleninka.ru/article/n/algoritmy-klasterizatsii-v-zadachah-segmentatsii-sputnikovyh-izobrazheniy (АЛГОРИТМЫ КЛАСТЕРИЗАЦИИ В ЗАДАЧАХ СЕГМЕНТАЦИИ СПУТНИКОВЫХ ИЗОБРАЖЕНИЙ, Пестунов Игорь Алексеевич, Синявский Юрий Николаевич)]

[[en:Cholesky decomposition]]

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

Участник:Elmon/Плотностный алгоритм кластеризации DBSCAN

2016-11-28T14:58:14Z

Dexter:

Участник:Elena777mc/Плотностный алгоритм кластеризации DBSCAN

2016-11-28T14:57:52Z

Dexter:

{{Assignment|Преподаватель 1|Dexter}}
{Assignment|Sleo}}

{{algorithm
| name = Плотностный алгоритм кластеризации DBSCAN
| serial_complexity = <math>O(n \log n)</math>
| pf_height = <math>O(|X| \log |X|)</math>
| pf_width = <math>O(m)</math>
| input_data = <math>n</math>
| output_data = <math>n</math>
}}

Основные авторы описания: [[Участник:Elena777mc|Малахова Е.С.]] (1.2, 1.4-1.8, 2.4, 2.7), [[Участник:Жаннат_Сагиолданова|Сагиолданова Ж.]] (1.1-1.3, 1.9-1.10, 3)

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

== Общее описание алгоритма ==
Кластеризация – это процесс разбиения множества с <math>N</math> элементами <math>x_1, x_2, ... , x_n (x_n</math> имеет размерность <math>m</math>) на <math>K</math> кластеров, так, чтобы в каждом кластере все элементы были схожи
в каком-то смысле. <math>x_i</math> могут быть числовыми, категориальными или смешанными данными. В плотностных методах кластеры рассматриваются как регионы пространства данных с высокой плотностью объектов, которые разделены регионами с низкой плотностью объектов.

Алгоритм DBSCAN (Density Based Spatial Clustering of Applications with Noise) <ref>A density-based algorithm for discovering clusters in large spatial database / M. Ester, H.-P. Kriegel,
J. Sander, X. Xu // Proc. 1996 Intern. Conf. on Knowledge Discovery and Data Mining. – 1996. – P. 226 –
231.</ref> –плотностной алгоритм для кластеризации пространственных данных с присутствием шума, был предложен Мартином Эстер, Гансом-Питером Кригель и их коллегами в 1996 году как решение проблемы разбиения (изначально пространственных) данных на кластеры произвольной формы.

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

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

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

[[File:Dbscan_picture.png|thumb|right|500px| Рис. 1. Пример ядровых, граничных и шумовых точек алгоритма. Точка A - ядровая, точки B и С - граничные, N - шум. В данном примере MinPts = 4, Eps равен радиусу окружности <ref>https://upload.wikimedia.org/wikipedia/commons/thumb/a/af/DBSCAN-Illustration.svg/400px-DBSCAN-Illustration.svg.png</ref>]]

Исходные данные: объекты, которые нужно кластеризовать, параметры <math>MinPts, \ \varepsilon</math> . Между объектами можно считать расстояния.

Вычисляемые данные: разбиение объектов по кластерам. Количество кластеров зависит от исходных данных. <ref>"Xu, X. A fast parallel clustering algorithm for large spatial databases / X. Xu, M. Ester, H.-P. Kriegel // Proc. 1999 Intern. Conf. on Knowledge Discovery and Data Mining. – 1999. – Vol. 3, is. 3. – P. 263 – 290.</ref>

Для построения оценки плотности, на основе соседства точек вводятся понятия
достижимости и связности. Под <math>\varepsilon </math> -соседями точки <math>x \in X</math> понимается множество точек, расстояние до которых не превышает <math>\varepsilon </math>, т. е.
<math>N_\varepsilon (x) = \{y \in X | D(x, y) \le \varepsilon\}</math>.
Тогда точка <math>y</math> достижима из точки <math>x</math>, если существует последовательность точек <math>x^{(1)}=x, x^{(2)},... , x^{(p-1)}, x^{(p)}=y</math>, для которой выполнено:
:<math>
\begin{align}
x^{(i+1)} \in N_\varepsilon (x^{(i)}), i=1,... ,p-1 \\
\mid N_\varepsilon (x^{(i)}) \mid \ge MinPts, i=1,... ,p-1
\end{align}
</math>

Здесь значение <math>MinPts</math> задаётся пользователем и регулирует порог «шума». Согласно второму условию, у точек, находящихся внутри кластера, должно быть не менее <math>MinPts \ \varepsilon</math> -соседей. Такие точки называются «ядрами». Остальные точки разделяются на граничные (имеющие менее <math>MinPts \ \varepsilon </math> -cоседей, но достижимые из какого-либо «ядра») и шумовые. Две точки связны, если существует «ядро», из которого они обе достижимы.
При такой постановке задачи, под кластером понимается максимальное связное подмножество множества <math>X</math> . Точки, не попавшие в какой-либо кластер (не принадлежащие <math>\varepsilon</math> -окрестности какого-либо «ядра»), относятся к классу «шум».

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

Вычислительным ядром алгоритма является нахождение <math>\varepsilon</math>-соседей каждого объекта входного множества <math>X</math>. На эту часть алгоритма приходится основное время работы алгоритма, так как требуется найти всех соседей для каждого объекта заданного множества. Основные операции, которые применяются в вычислительном ядре алгоритма: нахождение расстояние между объектами и сравнение расстояния с порогом для определения того, являются ли данные объекты <math>\varepsilon</math>-соседями.

== Макроструктура алгоритма ==
Алгоритм DBSCAN использует пространственную структуру данных для определения соседних объектов. Такие структуры данных позволяют найти все объекты в пределах определенного расстояния от текущего объекта. Сложность построения таких структур <math>O(n \log n)</math>, и использование такой структуры не увеличит сложность всего алгоритма (если сложность самого алгоритма <math>O(n \log n)</math>). Также для построения таких деревьев нужно уметь находить расстояния между объектами <math>\rho(u,v)</math>, это расстояние можно вводить разными способами. Например, если <math>\rho(u,v)</math> - метрика в евклидовом пространстве, <math>u=(u_1,...,u_n)</math> и <math>(v_1,...,v_n)</math>, то расстояние вычисляется следующим образом: <math>\rho(u,v)=\sqrt{(u_1-v_1)^2+(u_2-v_2)^2+...+(u_n-v_n)^2} = \sqrt{\sum_{k=1}^n(u_k-v_k)^2}</math>

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

// Основная функция, которая реализует алгоритм кластеризации
<math>DBSCAN(X, \varepsilon, MinPts)</math>
//Изначально все объекты в <math>X</math>не кластеризованы
<math>FORALL</math> objects <math>x</math> in <math>X\ DO</math>
<math>IF\ x</math> is unclassified
call function <math>expand\_cluster</math> to construct a cluster wrt. <math>\varepsilon</math> and <math>MinPts</math> containing <math>x</math>

// Функция, которая строит кластер на основе одной точки
<math>FUNCTION\ expand\_cluster(x,X,\varepsilon, MinPts):</math>
<math>retrive\_\varepsilon neighborhood(x, \varepsilon)</math>;
<math>IF \mid N_{\varepsilon}(x) \mid < MinPts</math> //т.е. <math>x</math> - объект, не являющийся ядром
mark <math>x</math> as <math>noise</math> and <math>RETURN</math>;
<math>ELSE</math>//т.е. <math>x</math> - объект, являющийся ядром
select a new cluster-id and mark all objects in <math>N_{\varepsilon}(x)</math> with this current <math>cluster-id</math>;
push all objects from <math>N_{\varepsilon}(x)</math>\<math>(x)</math> onto the stack seeds;
<math>WHILE\ NOT</math> seeds.empty() <math>DO</math>
<math>currentObject</math> := seeds.top();
seeds.pop();
<math>retrive\_\varepsilon neighborhood(currentObject, \varepsilon)</math>;
<math>IF \mid N_{\varepsilon}(currentObjects) \mid \ge MinPts</math>
select all objects in <math>N_{\varepsilon}(currentObject)</math> not yet classified or marked as <math>noise</math>,
push the unclassified objects onto seeds and mark all of these objects with current <math>cluster-id</math>;
<math>RETURN</math>

// Функция, для определения <math>\varepsilon</math>-соседей для объекта
<math>FUNCTION\ retrive\_\varepsilon neighborhood(x, \varepsilon)</math> //функция возвращает соседей на основе пространственной структуры данных
return <math>\{ x' \ | \ \forall x' \in X: \rho(x, x') < \varepsilon \}</math>

== Последовательная сложность алгоритма ==
Для того, чтобы алгоритм мог кластеризовать все объекты, необходимо пройти по каждому из них хотя бы один раз. Если использовать R*-дерево или kd-дерево для определения соседних объектов со сложностью <math>O(\log n)</math>, то сложность алгоритма <math>O(n \log n)</math>. Если не использовать эти структуры, то в худшем случае алгоритм будет иметь сложность <math>O(n^2)</math>, так как придется считать полную матрицу расстояний между объектами.

== Информационный граф ==
В настоящем алгоритме осуществляется параллелизм по данным. Ниже представлена общая структура данного алгоритма.
[[File:Dbscan_schema.jpg|1000px|thumb|center|Рис.1. Общая информационная структура алгоритма]]
Разбиение данных происходит с помощью пространственной структуры данных (R*-дерево, kd-дерево), которая разбивает все множество объектов <math>X</math> на <math>m</math> частей: <math>X_1,X_2,...,X_m</math>.
На каждой части объектов применяется алгоритм PDBSCAN. PDBSCAN - это последовательный алгоритм DBSCAN, применяемый только к одной части объектов, и для каждой из этих частей он определяет кандидатов на слияние. PDBSCAN использует пространственную структуру, которая распределяется вместе с данными.
Если для ядрового объекта части <math>X_i</math> в <math>\varepsilon</math>-окрестности находится объект из другой части <math>X_j</math>, то такие объекты становятся кандидатами на слияние.

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

[[File:dbscan_clusters_partitions.png|500px|thumb|center|Рис.2. Пример разбиения объектов на части на основе пространственной структуры. Каждый прямоугольник соответствует части данных, каждая из которых подается на вход алгоритму PDBSCAN <ref>https://github.com/bwoneill/pypardis/blob/master/plots/median_search_split/clusters_partitions.png</ref>]]

== Ресурс параллелизма алгоритма ==
Как видно из общей структуры графа алгоритма, ширина ярусно-параллельной формы алгоритма <math>O(m)</math>, где m - количество частей, на которые разбиваются все входное множество объектов <math>X</math>. Высотой ярусно-параллельной формы алгоритма является <math>O(|X| \log |X|)</math>, где <math>\mid X \mid</math> - максимальное количество среди числа объектов в каждой части разбиения. Именно такую сложность имеет алгоритм PDBSCAN, применяемый к каждой отдельной части разбиения.

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

'''Входные данные''': множество точек X из n-мерного пространства, на котором определена функция расстояния D. В наиболее распространенном случае пространственной кластеризации используется Евлидова метрика между векторами из <math>{R}^n</math>.

'''Объём входных данных''': n (размерность входящего множества)

'''Выходные данные''': размеченное множество точек X, в котором каждой точке соответствует номер ее кластера. Обычно каждой точке из X сопоставляется ее номер, а на выходе алгоритм дает отображение номеров точек в номера соответствующих им кластеров, например в виде вектора размера |X|

'''Объём выходных данных''': n (размерность выходящего множества)

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

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

''' Преимущества алгоритма '''

* алгоритм может обрабатывать большой объем данных и не зависит от порядка ввода данных;
* может определять кластера произвольной формы;
* параллельная реализация сбалансирована по количеству и виду производимых операций (вычисление расстояния, сравнение с <math>\varepsilon</math>);
* не требуется задание числа кластеров;
* может выделять кластеры в присутствии «шума»и выбросов <ref>АЛГОРИТМЫ КЛАСТЕРИЗАЦИИ В ЗАДАЧАХ СЕГМЕНТАЦИИ
СПУТНИКОВЫХ ИЗОБРАЖЕНИЙ/ И. А. Пестунов, Ю. Н. Синявский// Вестник Кемеровского государственного университета. – 2012. – P. 263–
299.</ref>;
* число итераций определяется заранее.

''' Недостатки алгоритма '''

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

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

== Особенности реализации последовательного алгоритма ==
== Локальность данных и вычислений ==
== Возможные способы и особенности параллельной реализации алгоритма ==
== Масштабируемость алгоритма и его реализации ==
Было проведено исследование масштабируемости параллельной реализации алгоритма DBSCAN . Исследование проводилось на суперкомпьютере "Ломоносов" [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета]. Исследовалась параллельная реализация алгоритма, написанная с использованием стандарта MPI. Распараллеливание проводилось по числу входных объектов, поэтому исследование масштабируемости проводилось для числа входных объектов. Алгоритм тестировался на известном датасете для кластеризации: [https://archive.ics.uci.edu/ml/datasets/Individual+household+electric+power+consumption Machine Learning Repository]

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

* число процессоров [1 : 128] с шагом по степеням двойки;
* число входных объектов [1000 : 40000].

На следующих рисунках приведены графики производительности и эффективности распараллеливания алгоритма DBSCAN в зависимости от изменяемых параметров запуска.
[[File:Dbscan_perfomance.png|800px|thumb|center|Рис.1. Изменение производительности в зависимости от числа процессов и числа входных данных]]
[[File:Dbscan_efficiency.png|800px|thumb|center|Рис.2. Изменение эффективности распараллеливания в зависимости от числа процессов и числа входных данных]]

Построим оценки масштабируемости протестированной параллельной реализации алгоритма DBSCAN:

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

'''По размеру задачи''' - При увеличении размерности системы при фиксированном количестве процессов на области изменений значений параметров наблюдается увеличение эффективности.

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

[https://github.com/elena777mc/dbscan/tree/master Исследованная параллельная реализация на языке C++]

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

* [http://scikit-learn.org/stable/modules/generated/sklearn.cluster.DBSCAN.html Scikit learn (Python, последовательная реализация)]
* [http://cucis.ece.northwestern.edu/projects/Clustering/download_code_dbscan.html Northwestern University (C++, параллельная реализация kd-tree)]
* [https://github.com/ContinuumIO/parallel_dbscan github/ContinuumIO (Python, параллельная реализация)]
* [https://github.com/propanoid/DBSCAN github/propanoid (C++, последовательная реализация VP tree)]
* [https://github.com/dparks1134/DBSCAN github/dparks1134 (С++, последовательная реализация)]
* [https://github.com/ahbarnett/validspike/tree/master/contrib/dbscan_patwary Disjoint-Set Data Structure based Parallel DBSCAN (C++ параллельная реализация kd-tree)]
* [https://github.com/bwoneill/pypardis github/bwoneill (Spark/Python параллельная реализация kd-tree)]
* [https://github.com/alitouka/spark_dbscan github/alitouka (Spark/Scala параллельная реализация)]
* [https://github.com/mhahsler/dbscan CRAN (R, последовательная реализация)]

= Литература =
<references \>
<references \>[https://pdfs.semanticscholar.org/a3f8/a3948e5999def4a0819d0dbaef2ae05e1599.pdf (A Fast Parallel Clustering Algorithm for Large Spatial Databases, JOCHEN JAGER, HANS-PETER KRIEGEL)]
<references \>[http://cyberleninka.ru/article/n/algoritmy-klasterizatsii-v-zadachah-segmentatsii-sputnikovyh-izobrazheniy (АЛГОРИТМЫ КЛАСТЕРИЗАЦИИ В ЗАДАЧАХ СЕГМЕНТАЦИИ СПУТНИКОВЫХ ИЗОБРАЖЕНИЙ, Пестунов Игорь Алексеевич, Синявский Юрий Николаевич)]

[[en:Cholesky decomposition]]

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

Участник:Dadrik/Плотностный алгоритм кластеризации

2016-11-28T14:57:30Z

Dexter:

{{Assignment|Преподаватель 1|Dexter}}
{{Assignment|Sleo}}

{{algorithm
| name = Плотностный алгоритм кластеризации DBSCAN
| serial_complexity = <math>O(n \log n)</math>
| input_data = <math>n</math>
| output_data = <math>n</math>
}}

Авторы описания: [[Участник:Dadrik | Вашуров И.М.]], [[Участник:ramon93i7 | Шемякин Р.О.]]

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

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

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

Алгоритм DBSCAN (Density-based spatial clustering of applications with noise)<ref>Ester, Martin, et al. "A density-based algorithm for discovering clusters in large spatial databases with noise." Kdd. Vol. 96. No. 34. 1996.</ref> был предложен Мартином Эстер, Гансом-Питером Кригель и коллегами в 1996 году как решение задачи кластеризации с кластерами произвольной формы. DBSCAN является непараметрическим плотностным алгоритмом кластеризации: для заданного набора точек в некотором пространстве, алгоритм группирует те точки, которые расположены достаточно близко друг к другу (точки с большим количеством соседей), и помечает как выбросы те, что располагаются далеко от ближайших соседей.

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

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

== Математическое описание алгоритма ==
Вход алгоритма: множество точек <math>X</math> из <math>n</math>-мерного пространства, на котором определена функция расстояния <math>D</math>.

Выход алгоритма: размеченное множество точек <math>X</math>, в котором каждой точке соответствует номер ее кластера.

Параметры алгоритма:
* <math>\varepsilon</math> - максимальное расстояние между соседями;
* <math>MinPts</math> - минимальное количество соседей для создания области связности.

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

[[File:Cluster_scheme.png|thumb|right|400px| Рис. 1. [https://upload.wikimedia.org/wikipedia/commons/a/af/DBSCAN-Illustration.svg] Здесь ''MinPts'' = 4. Точка ''A'' и другие красные точки - ядровые и образуют единый кластер, так как достижимы друг из друга. Точки ''B'' и ''C'' не являются ядровыми, но достижимы из ''A'', а значит также принадлежат кластеру. Точка ''N'' - не достижима из других точек и является шумом.]]

Все заданные точки классифицируются на три группы:

* ''ядровые точки'': точка <math>p</math> является ядровой, если количество <math>\varepsilon</math>-соседей, включая саму точку <math>p</math>, не меньше <math>MinPts</math>. Под ''<math>\varepsilon</math>-соседями'' точки <math>p \in X</math> понимается множество точек, расстояние до которых не превышает <math>\varepsilon</math>, т.е. <math>N_\varepsilon(p) = \{ x \in X | D(p, x) \le \varepsilon \}</math>. Эти точки являются напрямую достижимыми из <math>p</math>;

* ''достижимые точки'': точка <math>q</math> достижима из <math>p</math>, если существует путь <math>p_1, \dots, p_n</math>, где <math>p_1 = p</math> и <math>p_n = q</math>, для которого выполнено:
:<math>\begin{align}
p_{i + 1} \in N_\varepsilon(p_i), i = 1, \dots, n-1 \\
| N_\varepsilon(p_{i}) | \ge MinPts, i = 1, \dots, n-1 \\
\end{align}</math>

* ''шум'' (выбросы): все точки, недостижимые из какой-либо другой точки считаются шумом (выбросом).

Так, если <math>p</math> - ядровая точка, то она образует кластер вместе со всеми точками, достижимыми из неё. Каждый кластер содержит по крайней мере одну ядровую точку; неядровые точки могут быть частью кластера, образуя при этом его "границу", так как они не могут быть использованы для достижения других точек.

Достижимость не является симметричным отношением, так как по определению никакая точка не может быть достижима из неядровой точки, независимо от расстояния. Поэтому в DBSCAN применяется следующий термин ''связности'': две точки <math>p</math> и <math>q</math> связанны, если существует такая точка <math>o</math>, что <math>p</math> и <math>q</math> достижимы из <math>o</math>. Такое отношение связности симметрично.

''Кластер'' в таком случае определяется двумя свойствами:
* Все точки внутри кластера взаимно связанны;
* Если точка достижима из любой точки кластера, она также является частью кластера.

=== Шаги алгоритма ===

#Выбирается произвольная непосещенная точка <math>p</math>.
#Точка <math>p</math> помечается как посещенная.
#У точки <math>p</math> определяется множество её <math>\varepsilon</math>-соседей - <math>N_\varepsilon(p)</math>.
#*Если точка <math>p</math> оказалась ядровой - <math>| N_\varepsilon(p) | \ \ge MinPts</math>, то:
#**она становится началом нового кластера или сохраняет номер кластера, который был ей присвоен ранее;
#**все точки из <math>N_\varepsilon(p)</math> добавляются в её кластер;
#**процесс продолжается рекурсивно для каждой новой добавленной непосещенной точки <math>p' \in N_\varepsilon(p)</math> c шага 2 (в качестве новой <math>p</math>).
#*Если точка <math>p</math> оказалась не ядровой, то <math>p</math> объявляется шумом. Алгоритм продолжается с шага 4.
#Если остались непосещенные точки, то алгоритм продолжается с шага 1.

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

Вычислительным ядром алгоритма является нахождение <math>\varepsilon</math>-соседей каждой точки входного множества <math>X</math>.

Для решения этой задачи требуется найти расстояния между любыми двумя точками множества <math>X</math> по заданной метрике. Например, если используется расстояние Минковского порядка <math>k</math>, то расстояние между точками <math>p=(p_1,...,p_n) \in X</math> и <math>q=(q_1,...,q_n) \in X</math> вычисляется как <math>D(p, q) = (\sum_{i = 1}^{n}|p_i - q_i|^k)^{1 / k}</math>, частным случаем которой при <math>k = 2</math> является широко распространённая евклидова метрика <math>D(p, q) = \sqrt{\sum_{i = 1}^{n} (p_i - q_i)^2}</math>.

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

Как записано и в [[#Вычислительное ядро алгоритма|описании ядра алгоритма]], основную часть метода составляют вызовы функции <math>request\_neighbours</math> получения <math>\varepsilon</math>-соседей и нахождение расстояний между точками множества <math>X</math>.

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

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

<math>DBSCAN(\varepsilon, MinPts)</math>
<math>C = 0</math>
for <math>\forall p \in X</math>
if <math>p</math> is visited then
continue
mark <math>p</math> as visited
<math>neighbours</math> = <math>request\_neighbours(p, \varepsilon)</math>
if <math>| neighbours | < MinPts</math> then
mark <math>p</math> as <math>NOISE</math>
else
<math>C = next\_cluster</math>
<math>expand\_cluster(p, neighbours, C, \varepsilon, MinPts)</math>

<math>expand\_cluster</math> рекурсивно проходит через все точки множества <math>neighbours</math> - соседей точки <math>p</math>,
и определяет, принадлежат ли эти точки тому же кластеру <math>C</math>, тем самым расширяя этот кластер.

<math>expand\_cluster(p, neighbours, C, \varepsilon, MinPts)</math>
add <math>p</math> to cluster <math>C</math>
for <math>\forall p' \in neighbours</math>
if <math>p'</math> is not visited
mark <math>p'</math> as visited
<math>neighbours'</math> = <math>request\_neighbours(p, \varepsilon)</math>
if <math>| neighbours' | \ \ge MinPts</math>
<math>neighbours</math> = <math>neighbours \cup neighbours'</math>
if <math>p'</math> is not yet member of any cluster
add <math>p'</math> to cluster <math>C</math>

<math>request\_neighbours</math> возвращает для точки <math>p</math> множество всех её <math>\varepsilon</math>-соседей,
используя функцию расстояния <math>D</math>
<math>request\_neighbours(p, \varepsilon)</math>
return <math>\{ p' \ | \ \forall p' \in X: D(p, p') < \varepsilon \}</math>

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

DBSCAN проходит через каждую точку входного множества, возможно, по несколько раз. Временная сложность зависит в большей степени от вызова функции <math>request\_neighbours</math> (нахождение <math>\varepsilon</math>-соседей для заданной точки). Эта функция вызывается ровно один раз для каждой точки множества <math>X</math>.

Если использовать индексированную структуру данных (например, R-деревья), выполняющую операцию <math>request\_neighbours</math> за <math>O(\log n)</math>, то суммарная сложность алгоритма в среднем составит <math>O(n \log n)</math>, с учётом хорошо подобранного параметра <math>\varepsilon</math>, такого что в среднем <math>request\_neighbours</math> возвращает <math>O(\log n)</math> точек. Без использования ускоряющих структур или на вырожденных данных (таких, что все точки находятся на расстоянии меньшем, чем <math>\varepsilon</math> друг от друга) сложность по времени в худшем случае будет <math>O(n^2)</math>.

Расстояния между точками можно вычислить заранее за <math>O(\frac {n(n - 1)}{2})</math>, например в виде матрицы расстояний, но это потребует <math>O(n^2)</math> памяти. Иначе, расстояния будут вычисляться при каждом запуске функции <math>request\_neighbours</math> за <math>O(n)</math> и потребуют <math>O(n)</math> памяти. Итоговая сложность вычисления расстояний в таком случае составляет <math>O(n^2)</math>. Сложность рассчета расстояний зависит от природы объектов из <math>X</math> и заданной метрики <math>D</math>. Например, если <math>X\subset\mathbb{R}^m</math>, то сложность равна <math>O(m)</math>, но оценка может быть улучшена при использовании векторных операций.

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

Опишем граф алгоритма<ref>Воеводин В.В. Математические основы параллельных вычислений// М.: Изд. Моск. ун-та, 1991. 345 с.</ref><ref>Воеводин В.В., Воеводин Вл.В. Параллельные вычисления. – СПб.: БХВ - Петербург, 2002. – 608 с.</ref><ref>Фролов А.В.. Принципы построения и описание языка Сигма. Препринт ОВМ АН N 236. М.: ОВМ АН СССР, 1989.</ref>.

[[File:Dbscan abstract.png |thumb|right|320px| Рис. 2. Внешний цикл алгоритма.]]

На рис. 2 изображен информационный граф внешнего цикла алгоритма, который соответствует коду основной функции <math>DBSCAN</math>:
*Макрооперация ''Init'' заключается в получении множества <math>X</math> и инициирования вспомогательных структур.
*Макрооперация ''Choose'' производит выбор непосещенной точки из <math>X</math>.
*Макрооперация ''Build cluster'' строит кластер, если точка ядровая, или объявляет ее шумом.

Переход от ''Build cluster'' к ''Choose'' заключает в себе зависимость данных о принадлежности некоторых точек к текущему кластеру или шуму и об их посещенности.

[[File:Expand cluster 2.png |thumb|right|600px| Рис. 3. Расширение кластера.]]

На рис. 3 изображен информационный граф алгоритма расширения кластера из начальной точки кластера:
*Макрооперация ''Init'' заключается в создании кластера из его начальной вершины.
*Макрооперация ''Nε'' вычисляет множество <math>\varepsilon</math>-соседей.
*Желтым цветом обозначены узлы, в которых точки из <math>\varepsilon</math>-соседей классифицируются на ядровые, граничные точки и шум. В рамках операции для конкретного соседа вычисляется множество его <math>\varepsilon</math>-соседей.
*Макрооперации ''Ñε'', ''Ňε'', ... производят объединение входных множеств.
*Макрооперация ''Ø'' выполняется тогда, когда объединение входных множеств является пустым.

[[File:N eps 3.png |thumb|right|320px| Рис. 4. Подсчет <math>\varepsilon</math>-соседей.]]

На рис. 4 изображен информационный граф алгоритма вычисления множества <math>\varepsilon</math>-соседей:
*Операция ''D'' - вычисление расстояния между точками.
*Операция ''ε'' - сравнение расстояния с ε.
*Операция ''U'' - объединение результатов.

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

Поиск <math>\varepsilon</math>-соседей требует вычисления <math>n</math> расстояний (функция <math>D</math>) и выполнения <math>n</math> сравнений с <math>\varepsilon</math>. Эти операции для каждой пары точек независимы и могут быть выполнены параллельно. Таким образом, при наличии неограниченного числа процессоров сложность поиска составит <math>O(1)</math>. Т.к. поиск выполняется для каждой точки ровно один раз, параллельная сложность всего алгоритма составит <math>O(n)</math>.

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

Вход алгоритма: множество точек X из n-мерного пространства, на котором определена функция расстояния D. В наиболее распространенном случае пространственной кластеризации используется Евлидово расстояние между векторами из <math>\mathbb{R}^n</math>.

Выход алгоритма: размеченное множество точек <math>X</math>, в котором каждой точке соответствует номер ее кластера. Обычно каждой точке из <math>X</math> сопоставляется ее номер, а на выходе алгоритм дает отображение номеров точек в номера соответствующих им кластеров, например в виде вектора размера <math>|X|</math>.

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

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

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

=== Преимущества алгоритма ===

# не требует указывать число кластеров;
# может определять кластера произвольной формы;
# может определять шум и устойчив к выбросам;
# требует всего два параметра и по в большинстве случаев не чувствителен к порядку заданных точек;
# параллельная реализация сбалансирована по количеству и виду производимых операций (вычисление расстояния, сравнение с <math>\varepsilon</math>).

=== Недостатки алгоритма ===

# не детерминирован: граничные точки, достижимые из более, чем одного кластера, могут быть частью любого из них в зависимости от порядка обрабатываемых данных. Однако такая ситуация возникает редко, а относительно ядровых точек и шума DBSCAN детерминирован. Впрочем, от недетерминизма можно избавиться, если считать все граничные точки шумом (алгоритм DBSCAN*);
# качество алгоритма зависит от используемой функции расстояния <math>D</math>. Наиболее часто используемое Евклидово расстояние в многомерных множествах может оказаться практически бесполезным из-за так называемого "проклятия размерности", значительно затрудняя нахождение подходящего значения <math>\varepsilon</math>;
# не может выделять кластеры, имеющие разную плотность, так как параметры алгоритма не могут быть выбранны отдельно для каждого кластера.

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

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

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

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

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

!!! ЭКСПЕРИМЕНТЫ ДО 15 НОЯБРЯ !!!

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

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

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

* [http://scikit-learn.org/stable/modules/generated/sklearn.cluster.DBSCAN.html Scikit learn (Python)]
* [https://cran.r-project.org/web/packages/dbscan/dbscan.pdf R-project] ([https://github.com/mhahsler/dbscan github])
* [https://www.mathworks.com/matlabcentral/fileexchange/52905-dbscan-clustering-algorithm Matlab]
* P-DBSCAN (Parallel DBSCAN)<ref>Chen, Min, Xuedong Gao, and HuiFei Li. "Parallel DBSCAN with priority r-tree." Information Management and Engineering (ICIME), 2010 The 2nd IEEE International Conference on. IEEE, 2010.</ref>
* Parallel DBSCAN with MPI<ref>Savvas, Ilias K., and Dimitrios Tselios. "Parallelizing DBSCaN Algorithm Using MPI." Enabling Technologies: Infrastructure for Collaborative Enterprises (WETICE), 2016 IEEE 25th International Conference on. IEEE, 2016.</ref>
* PDSDBSCAN (Parallel Disjoint-Set DBSCAN)<ref>Patwary, Md Mostofa Ali, et al. "A new scalable parallel DBSCAN algorithm using the disjoint-set data structure." High Performance Computing, Networking, Storage and Analysis (SC), 2012 International Conference for. IEEE, 2012.</ref>

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

<references />

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

2016-11-27T19:35:57Z

Dexter:

'''Новые замечания'''

1) В верхней врезке нет свойств параллельной версии алгоритма (см страницу-образец)

2) Называть множества маленькими буквами - плохая идея

3) На рис.2 показана ситуация для шага t, но буква t не участвует в подписях на рисунке

== Статья [[Участник:Maria Zaitseva/PAM (Partitioning Around Medoids)]] ==

=== Замечания по тексту ===
* Название статьи лучше дать в развёрнутом виде. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 16:53, 27 октября 2016 (MSK)
* В разделе 1.4 нужно не дублировать информацию из раздела 1.3, а описать алгоритм на верхнем уровне. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 16:53, 27 октября 2016 (MSK)
* В разделе 1.5 кроме псевдокода требуются текстовые пояснения. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 16:53, 27 октября 2016 (MSK)
* В разделе 1.5 требуются указать объёмы входных и выходных данных. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 16:53, 27 октября 2016 (MSK)
** Имелся в виду раздел 1.9, конечно же.
* В разделе 2.4 не приведены все параметры запуска теста - какой компилятор, с какими опциями использовался, какая версия MPI, на каких узлах проводился запуск и т.д. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 15:16, 16 ноября 2016 (MSK)

=== Отсутствующие части ===
* Не указан вклад каждого из авторов статьи. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 16:53, 27 октября 2016 (MSK)

Участник:Denemmy/Partitioning Around Medoids (Алгоритм)

2016-11-27T19:28:51Z

Dexter:

{{Assignment|Преподаватель 1|Dexter}}
{{Assignment|Zhum}}

{{algorithm
| name = Partitioning Around Medoids
| serial_complexity = <math>O(T*K*N^2)</math>
| input_data = <math> N*(N-1)/2 + 2 </math>
| output_data = <math> N </math>
}}

Авторы: [[Участник:Denemmy|Галеев Д.Ф]], [[Участник:zaputlyaev|Запутляев И.]]

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

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

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

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

Алгоритм '''Partitioning Around Medoids''' ('''PAM''') был создан Леонардом Кауфманом (Leonard Kaufman) и Питером Руссивом (Peter J. Rousseeuw)<ref>Kaufman, L. and Rousseeuw, P.J., Clustering by means of Medoids. Statistical Data Analysis Based on the L1-Norm and Related Methods. Springer US; 1987, p. 405–416.</ref>. и он очень похож на алгоритм K-means, в основном потому, что оба являются алгоритмами кластеризации, другими словами, оба разделяют множество объектов на группы (кластеры) и работа обоих основана на попытках минимизировать ошибку, но PAM работает с медоидами - объектами, являющимися частью исходного множества и представляющими группу, в которую они включены, а K-means работает с центроидами - искусственно созданными объектами, представляющими кластер.

Алгоритм PAM разделяет множество из N объектов на K кластеров, где и множество объектов, и число K являются входными данными алгоритма. Алгоритм работает с матрицей расстояний, его цель - минимизировать расстояние между представителями каждого кластера и его членами. Алгоритм использует следующую модель для решения задачи:<ref>Fasulo D. An analysis of recent work on clustering algorithms. – Technical report, 1999. – №. 01-03. – С. 02.</ref>

<math>F(x)=minimize \sum_{i=1}^{N}\sum_{j=1}^{N} d(i,j)z_{ij}</math>

При этом:

1. <math> \sum_{i=1}^N {z_{ij} = 1} , j = 1,2,...,N</math>;

2. <math>z_{ij} \le y_i , i, j = 1,2,...,N</math>;

3. <math>\sum_{i=1}^N {y_i = K} , K - </math> число кластеров;

4. <math>y_i , z_{ij} \in \{ 0,1 \} , i, j = 1,2,...,N</math>.

где функция <math>F(x)</math> - целевая минимизируемая функция, <math>d(i,j)</math> - мера расстояния между объектами <math>i</math> и <math>j</math>, <math>z_{ij}</math> - переменная, которая гарантирует, что расстояние только между объектами из одного кластера будет вычислено в целевой функции. Остальные выражения являются следующими ограничениями:

1. Каждый объект принадлежит одному и только одному кластеру;

2. Каждый объект относится к медоиде, представляющей его кластер;

3. Есть в точности K кластеров;

4. Решающая переменная принимает значения 0 или 1.

PAM может работать с двумя типами входных данных:

1. С матрицей объектов и значениями ее переменных;

2. С матрицей расстояний.

Алгоритм имеет две фазы:

Фаза '''Build''':

1. Выбрать K объектов в качестве медоид;

2. Построить матрицу расстояний, если она не была задана;

3. Отнести каждый объект к ближайшей медоиде;

Фаза '''Swap''':

4. Для каждого кластера найти объекты, снижающие среднее расстояние, и если такие объекты есть, выбрать те, которые снижают его сильней всего, в качестве медоид;

5. Если хотя бы одна медоида поменялась, вернуться к шагу 3, иначе завершить алгоритм.

=== Математическое описание алгоритма ===
''Обозначения'':

1. <math>M = \{ x_{m_1}, x_{m_2}, ... , x_{m_s} \} - </math> множество медоид;

2. <math>L = \{ x_{l_1}, x_{l_2}, ... , x_{m_t} \} - </math> множество объектов <math>x_i</math>, не являющихся медоидами;

3. <math>F_{M,L} = \sum_{j = 1}^{N} \min_{ x_{m_q} \in M} d(x_{m_q},x_{l_j}) - </math> целевая функция.

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

1. Множество <math>X = \{ x_{1}, x_{2}, \dots, x_{N} \}</math> объектов <math>x_i</math>, каждый из который задается <math>P</math> вещественными значениями;

2. Симметрическая матрица <math>D</math>, элементы <math>d_{ij} = d(x_i,x_j)</math> которой являются расстояниями между объектами <math>x_i</math> и <math>x_j</math>;

3. Число кластеров <math>K \le N</math>;

4. Метрика <math>d_{ij} = d(x_i,x_j)</math>, задающая расстояние между объектами <math>x_i</math> и <math>x_j</math>.

''Вычислительные формулы метода'':

Фаза '''Build''':

Представляет из себя выбор K медоид за K последовательных шагов:

1. <math>M_0 = \varnothing, L_0 = X</math>;

2. <math>x_{m_i} = \arg \min_{x_{l_q} \in L_0} \sum_{j = 1}^N d(x_{l_q},x_j), L_1 = L_0 \backslash \{x_{m_i}\}, M_1 = M_1 \cup \{x_{m_i}\}, i=1 \dots N </math>;

Фаза '''Swap''':

Представляет из себя итерационный процесс.

1. Начальное приближение: <math>M_0 = M_{BUILD}, L_0 = L_{BUILD}</math>;

2. Множественные вычисления значений целевой функции для различных вариантов замены текущей медоиды на новую:

<math>F = arg \min_{i \in M , j \in L} \sum_{y \in L \backslash \{j\}} {min (d(i,y),d(j,y))} </math>;

3. Изменение множеств в соответствии с выбранной парой <math>(x_{m_t}, x_{l_q})</math>:

<math>M_i = M_{i-1} \backslash \{x_{m_t}\} \cup \{x_{l_q}\} , L_i = L_{i-1} \cup \{x_{m_t}\} \backslash \{x_{l_q}\} </math>;

4. Проверка критерия останова.

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

1. <math>M = \{ x_{m_{1}}, x_{m_{2}}, ..., x_{m_{K}} \}</math> - множество медоид;

2. <math>K_{m_i} = \{ x_{l_q} \in L \| x_{m_i} = \arg \min_{x_{m_s} \in M} d(x_{l_q}, x_{m_s}) \}, i=1 \dots K, K -</math> множество искомых кластеров.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма PAM сосредоточено в стадии '''SWAP''' и состоит из вычислений значений целевой функции для различных вариантов замены текущей медоиды на новую:

<math>F = arg \min_{i \in M , j \in L} \sum_{y \in L \backslash \{j\}} {min (d(i,y),d(j,y))} </math>

=== Макроструктура алгоритма ===
Если на вход алгоритма была подана не матрица расстояний, а матрица объектов с их координатами в пространстве <math>R^P</math>, то операция вычисления расстояния между объектами <math>a</math> и <math>b</math> размерности <math>P</math> будет являться макрооперацией. В качестве меры расстояния может быть использована евклидова метрика:
<math> d(a,b) = \sqrt{\sum_{i=1}^P (a_i-b_i)^2}</math>

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

''Псевдокод алгоритма'' <ref>Park H. S., Jun C. H. A simple and fast algorithm for K-medoids clustering //Expert Systems with Applications. – 2009. – Т. 36. – №. 2. – С. 3336-3341.:</ref>

1 функция PAM(D, k, tmax=100):
2 # D - матрица расстояний, k - число кластеров, tmax - маскимальное число итераций
3 выполнить фазу BUILD, получить множество метоидов M и множество не-метоидов L
4 вычислить значение целевой функции F
5 для t = 0..tmax-1:
6 выполнить фазу SWAP, вычислить значение целевой функции F'
7 delta = F - F'
8 если delta > 0:
9 обновить множества M и L
10 F = F'
11 иначе:
12 выйти из цикла
13 вернуть М

=== Последовательная сложность алгоритма===
Обозначим количество кластеров как <math>K</math>, количество объектов как <math>N</math>, число итераций алгоритма как <math>T</math>.

На стадии '''BUILD''' каждый шаг нахождения очередного метоида имеет сложность <math>O(N^2)</math> по количеству операций сложения вещественных чисел и по количеству операций сравнения двух вещественных чисел.
 Тогда стадия '''BUILD''' имеет сложность <math>O(K*N^2)</math>

На стадии '''SWAP''' вычисление целевой функции имеет сложность <math>O(K*N^2)</math> по количеству операций сложения вещественных чисел и по количеству операций сравнения двух вещественных чисел.

Таким образом алгоритм PAN имеет сложность <math>O(T*K*N^2)</math>

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

'''Фаза BUILD'''

Общий вид информационного графа для шага t представлен на рисунке 1:

[[Файл:BUILD_2.png|thumb|center|800px|Рисунок 1. Информационный граф шага t фазы BUILD алгоритма.]]

''Операции''
<ul>
<li>Update<math>_M</math> и Update<math>_L</math> - операции обновления множества метоидов и не-метоидов соответственно</li>
<li>SUM - вычисление функции ошибки, на вход подается расстояния от очередного объекта до всех остальных, а также минимальные расстояния от выбранных на данном шаге метоидов до всех остальных вершин</li>
<li>MIN<math>_s</math> - нахождение аргумента, соответствующего минимальному значению, а также само минимальное значение</li>
<li>MIN<math>_d</math> - нахождение минимальных расстояний от медоидов до остальных вершин, используется в операции SUM</li>
</ul>
Количество шагов t равно K, где K - число кластеров

'''Фаза SWAP'''

Общий вид информационного графа для итерации t представлен на рисунке 2:

[[Файл:SWAP_2.png|thumb|center|800px|Рисунок 2. Информационный граф итерации t фазы SWAP алгоритма.]]

''Операции''
<ul>
<li>Update<math>_M</math> и Update<math>_L</math> - операции обновления множества метоидов и не-метоидов соответственно</li>
<li>SUM - вычисление целевой функции</li>
<li>MIN - нахождение аргумента, соответствующего минимальному значению, а также само минимальное значение</li>
</ul>

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

Пусть число кластеров равно <math>K</math>, а число объектов равно <math>N</math>. Тогда параллельная сложность фазы BUILD имеет <math>O(K*N)</math> операций сложения и <math>O(K*N)</math> операций сравнения двух вещественных чисел. Таким образом параллельная сложность фазы BUILD равна <math>O(K*N*T)</math>.

Параллельная сложность фазы SWAP имеет <math>O(K*N)</math> операций сложения и <math>O(K*N)</math> операций сравнения двух вещественных чисел. Параллельная сложность фазы SWAP равна <math>O(K*N*T)</math>.

Таким образом параллельная сложность алгоритма равна <math>O(K*N*T)</math>.

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

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

''Выходные данные'':
* K чисел <math>m_1, m_2, ..., m_K</math> - индексы объектов соответствующие метоидам;
* N-K чисел <math>k_1, k_2, ..., k_{N-K}</math> - номера кластеров для каждого объекта (кроме тех, что являются метоидами);
''Объём выходных данных'': <math>N</math> целых чисел.

=== Свойства алгоритма ===
[[глоссарий#Вычислительная мощность|''Вычислительная мощность'']]
Суммарный объем входных данных равен <math> O(N^2) </math> , число операций алгоритма '''PAM''' равно <math> O(K*N^2*\Tau) </math>, где <math>K</math> – число кластеров, <math>\Tau</math> – число итераций алгоритма, <math> N </math> - число точек. Тогда вычислительная мощность алгоритма '''PAM''' равна <math>O(K*\Tau)</math>.

[[глоссарий#Детерминированность |''Детерминированность'']] и [[глоссарий#Устойчивость |''Устойчивость'']] 
Алгоритм PAM является итерационным, количество итераций может быть ограничено сверху, однако в общем случае не фиксируется. Из-за недетермирированности выбора элементов, на которых достигается минимум целевой функции, алгоритм не является детермирированным. Однако, данный алгоритм является устойчивым, поскольку не накапливает ошибки в процессе своей работы. <ref>Нейский И. М. Классификация и сравнение методов кластеризации //ББК 32.813 И 76 Составитель: ЮН Филиппович. – 2006. – С. 130.</ref>

Сильные стороны алгоритма:
<ul>
<li>Меньшая чувствительность к выбросам, чем k-means</li>
<li>Несложность реализации</li>
<li>
Возможность распараллеливания
Однако равномерная загрузка процессоров не всегда возможна.
</li>
</ul>
Недостатки алгоритма:
<ul>
<li>Квадратичная сложность алгоритма</li>
<li>
Количество кластеров является параметром алгоритма
Во многих задачах число кластеров может быть неизвестным.
</li>
<li>
Возможность сходимости к локальному оптимуму
Оптимальное решение не гарантировано.
</li>
</ul>

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

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

Данные были сгенерированы в '''Matlab'е''' случайным образом. Количество кластеров равно '''16''', каждый кластер был промоделирован нормальным распределением с некоторыми случайными значениями среднего и среднеквадратического отклонения. Размерность данных равна '''2''', а число точек на каждый кластер было достаточно большим для проведения экспериментов с различными значениями размерности матрицы расстояний. Пример сгенерированных данных показан на рисунке 3.

[[Файл:16_clusters.jpg|thumb|center|512px|Рисунок 3. Пример сгенерированных данных.]]

Измерялось '''время выполнения''' стадий '''BUILD''' и '''SWAP''', без учета времени, потраченного на построение матрицы расстояний, а также измерялось '''число итераций''' алгоритма.
Были проведены эксперименты для следующих значений размерности матрицы расстояний и числа процессоров:

Значения размерности: [2500, 2000, 1500, 1000, 500, 200, 150, 100, 50]
Значения числа процессоров: [500, 400, 256, 128, 64, 32, 16, 8, 4, 1]

Полученные графики производительности и эффективности представлены на рисунках 4 и 5 соответственно.

[[Файл:GFLOPS.png|thumb|center|512px|Рисунок 4. Зависимость производительности реализации параллельного алгоритма от размера матрицы и числа процессоров]]
[[Файл:EFF.png|thumb|center|512px|Рисунок 5. Зависимость эффективности реализации параллельного алгоритма от размера матрицы и числа процессоров.]]

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

В экспериментах была использована сторонняя реализация алгоритма, с небольшими изменениями она выложена в репозитории[https://denemmy@bitbucket.org/denemmy/pam.git]

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

<ol>
<li>[http://research.omicsgroup.org/index.php/ELKI ELKI] реализует несколько вариантов алгоритма кластеризации, включая алгоритм PAM. Написан на Java</li>
<li>[http://java-ml.sourceforge.net/ Java-ML]. Включает реализацию k-metoid. Написан на Java</li>
<li>[http://research.omicsgroup.org/index.php?title=Julia_language&action=edit&redlink=1 Julia] содержит реализацию k-metoid в пакете для кластеризации JuliaStats</li>
<li>[http://research.omicsgroup.org/index.php/R_(programming_language) R] включает различные варианты k-means в пакете flexclust. Алгоритм PAM реализован в пакете cluster</li>
<li>[http://research.omicsgroup.org/index.php/MATLAB MATLAB]. Реализованы PAM, CLARA и другие алгоритмы кластеризации</li>
<li>[http://research.omicsgroup.org/index.php/Python_(programming_language) Python]. Алгоритм PAM реализован как k-medoids в пакете pyclust, содержащем также различные варианты k-means</li>
</ol>

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

Обсуждение участника:Мязина Екатерина/Алгоритм концептуальной кластеризации COBWEB

2016-11-24T08:43:39Z

Dexter:

1) Во врезке сверху отсутствует информация о параллельной версии алгоритма - см. образцовую статью

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

3) Пункты 2.1, 2.4 не заполнены

Обсуждение участника:Мязина Екатерина/Алгоритм концептуальной кластеризации COBWEB

2016-11-24T08:42:06Z

Dexter: Новая страница: «1) Во врезке сверху отсутствует информация о параллельной версии алгоритма - см. образцов…»

1) Во врезке сверху отсутствует информация о параллельной версии алгоритма - см. образцовую статью

Обсуждение участника:Руслан/Плотностный алгоритм кластеризации

2016-11-24T08:38:49Z

Dexter:

1) Ссылки на источнике есть, но работы в списке не пронумерованы. Плюс сам список литературы оформлен неряшливо, со сдвигами в первых источниках

2) Поясните, что значит "плотно-достижимые"

Участник:Avasilenko/Partitioning Around Medoids (PAM)

2016-11-24T08:28:04Z

Dexter:

{{Assignment|Преподаватель 1|Dexter}}
{{Assignment|Zhum}}

{{algorithm
| name = Partitioning Around Medoids
| serial_complexity = <math>O(T*kn^2)</math>
| input_data = <math>n*(n-1)+2</math>
| output_data = <math>k+1</math>
| pf_height = <math>O(T*kn)</math>
| pf_width = <math>O(k(n-k))</math>
}}

'''Авторы''':
* [[Участник:Avasilenko|А.Э.Василенко]] (отвечает за программистскую составляющую);
* [[Участник:Anastasia|А.В.Тузикова]] (отвечает за математическую составляющую).
Вклад авторов считать равноценным, чётких границ ответственности провести невозможно.

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

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

Объединение схожих объектов в группы - один из важнейших видов человеческой деятельности<ref>Rousseeuw P. J., Kaufman L. Finding Groups in Data. – Wiley Online Library, 1990.</ref>. Более того - это важная часть процесса познания мира, в котором мы живем. Мы учим детей различать кошек и собак, воду и песок, мужчин и женщин путем постоянного развития и улучшения подсознательных схем классификации. Примеры есть и во взрослой жизни – в химии необходимо классифицировать соединения, в археологии – объединять находки по периодам и т.д.

'''Задача кластеризации''' - разделение множества объектов на заданное число множеств с минимизацией некоторого функционала - является популярной задачей, относится к разделу машинного обучения и находит применение в таких областях, как анализ текста, биоинформатика, интеллектуальные транспортные системы и др. <ref> Речкалов Т.В. Параллельный алгоритм кластеризации для многоядерного сопроцессора Intel Xeon Phi // Суперкомпьютерные дни в России: Труды vеждународной конференции. – М.: Изд-во МГУ, 2015, c. 532.</ref>

Существует несколько видов кластеризации<ref>Маннинг К.Д., Введение в информационный поиск: пер. с англ. / К.Д. Маннинг, П. Рагхаван, Х.Шютце - М. : Вильямс, 2011. - 528.</ref>:

* ''плоская кластеризация'' (''flat clustering'') - порождает совокупность кластеров, не имеющих явных взаимосвязей;
* ''иерархическая кластеризация'' (''hierarchical clustering'') - создаёт иерархию кластеров.

'''PAM''' ('''Partitioning Around Medoids''') - плоский алгоритм кластеризации, позволяющий выделить <math>k</math> кластеров (множеств), удовлетворяющих следующим свойствам:

* каждая группа содержит хотя бы один объект;
* каждый объект принадлежит ровно одной группе.

Модель <ref>Kaufman, L. and Rousseeuw, P.J., Clustering by means of Medoids. In: Y. Dodge and North-Holland, editor. Statistical Data Analysis Based on the L1-Norm and Related Methods. Springer US; 1987, p. 405–416.</ref>, лежащая в основе алгоритма PAM, основана на выборе <math>k</math> объектов, являющихся характерными точками соответствующего кластера. Таким образом, кластерам сопоставляются принадлежащие им объекты, называемые '''медоидами''', на основании которых распределяются остальные объекты по принципу наибольшего сходства. Cама модель называется моделью '''k-medoids''' (не путать с моделью ''k-median'').

PAM состоит из двух фаз: '''BUILD''' и '''SWAP''':

* на фазе BUILD выполняется первичная кластеризация, в ходе которой последовательно выбираются <math>k</math> объектов в качестве медоидов;
* фаза SWAP представляет собой итерационный процесс, в ходе которого производятся попытки улучшить множество медоидов. Алгоритм выполняет поиск пары объектов (медоид, не-медоид), минимизирующих целевую функцию при замене, после чего обновляет множество медоидов.

На каждой итерации алгоритма выбирается пара (медоид, не-медоид) такая, что замена медоида <math>x_{m_l}</math> на не-медоид <math>x_{o_h}</math> дает лучшую кластеризацию из возможных. Оценка кластеризации выполняется с помощью целевой функции, вычисляемой как сумма расстояний от каждого объекта до ближайшего медоида:

:<math>E = \sum_{j = 1}^n \min_{1 \leq l \leq k} \rho ( x_{m_l},x_{o_j} )</math>

Процедура изменения множества медоидов повторяется, пока есть возможность улучшения значения целевой функции.

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

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

* множество кластеризуемых объектов <math>X = \{ x_1, x_2, ... , x_n \} </math>, где <math>x_i</math> - кортеж, состоящий из <math> w </math> вещественных чисел;
* симметрическая матрица <math>D</math>, элементы матрицы <math>d_{ij}=d(i,j)</math> - вычисленные расстояния между объектами <math>x_i, x_j</math>;
* количество кластеров <math>k \leq n.</math>

''Обозначения'':
* <math>M = \{ x_{m_1}, x_{m_2}, ... , x_{m_k} \} </math> - множество медоидов, <math> M \subseteq X ;</math>
* <math>O = \{ x_{o_1}, x_{o_2}, ... , x_{o_r} \} </math> - множество не-медоидов, <math> O \subseteq X, </math> где <math>r=n-k;</math>
* <math>d_{ij}=\rho (x_i, x_j )</math>, где <math> \rho : X \times X \rightarrow R </math> — метрика расстояния;
* <math>F_{M,O} = \sum_{j = 1}^{n} \min_{ x_{m_l} \in M} \rho ( x_{m_l},x_{o_j} )</math> - значение целевой функции для заданных множеств <math>M</math> и <math>O;</math>
* <math>T^i</math> - изменение целевой функции на <math>i</math>-м шаге фазы SWAP.

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

* <math>M = \{ x_{m_1}, x_{m_2}, ... , x_{m_k} \}</math> - множество медоидов;
* <math>K_{m_i} = \{ x_{o_h} \in O \| x_{m_i} = \arg \min_{x_{m_s} \in M} \rho (x_{o_h}, x_{m_s}) \}, 1 \leq i \leq k</math> - искомые кластеры.

''Вычислительные формулы метода'':

* ''фаза BUILD'' (состоит из <math>k</math> шагов последовательного выбора <math>k</math> медоидов):
** <math>O_0 = X, M_0 = \varnothing ;</math>
** <math>x_{m_1} = \arg \min_{x_{o_h} \in O_0} \sum_{j = 1}^n \rho \left ( x_{o_h},x_j \right ), O_1 = O_0 \backslash \{x_{m_1}\}, M_1 = M_1 \cup \{x_{m_1}\} ; </math>
** <math>x_{m_2} = \arg \min_{x_{o_h} \in O_1} \sum_{j = 1}^{n} \min ( \rho ( x_{m_1},x_j ), \rho ( x_{o_h},x_j ) ), O_2 = O_1 \backslash \{x_{m_2}\}, M_2 = M_1 \cup \{x_{m_2}\} ; </math>
** <math>x_{m_3} = \arg \min_{x_{o_h} \in O_2} \sum_{j = 1}^{n} \min_{1 \leq l \leq 2} ( \rho ( x_{m_l},x_j ) , \rho ( x_{o_h},x_j ) ) , O_3 = O_2 \backslash \{x_{m_3}\}, M_3 = M_3 \cup \{x_{m_3}\} ; </math>
** ...
** <math>x_{m_k} = \arg \min_{x_{o_h} \in O_{k-1}} \sum_{j = 1}^{n} \min_{ x_{m_l} \in M_{k-1}} ( \rho ( x_{m_l},x_j ), \rho ( x_{o_h},x_j ) ) , O_k = O_{k-1} \backslash \{x_{m_k}\}, M_k = M_{k-1} \cup \{x_{m_k}\} ; </math>

* ''фаза SWAP'' (итерационный процесс):
** начальное приближение: <math>O_0 = O_k^{BUILD}, M_0 = M_k^{BUILD};</math>
** <math>i</math>-й шаг итерации:
*** вычисление целевой функции при оптимальной замене (замене, при которой достигается лучшая кластеризация из возможных на текущей итерации): <math>F^i = \min_{x_{m_s} \in M_{i-1} , x_{o_h} \in O_{i-1}} \sum_{j = 1}^{n} \min_{ x_{m_l} \in M_{i-1} \backslash \{x_{m_s}\} } ( \rho ( x_{m_l},x_j ), \rho ( x_{o_h},x_j) ); </math>
*** определение пары (медоид, не-медоид), на которой достигается оптимальная замена: <math> (x_{m_s}, x_{o_h}) = \arg F^i; </math>
*** проверка критерия останова;
*** изменение множеств в соответствии с выбранной парой <math> (x_{m_s}, x_{o_h}):</math> <math>M_i = M_{i-1} \backslash \{x_{m_s}\} \cup \{x_{o_h}\} , O_i = O_{i-1} \cup \{x_{m_s}\} \backslash \{x_{o_h}\} ;</math>
** критерий останова:
*** <math>T^i = F^{i-1} - F^{i} \leq 0 .</math>

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

'''Вычислительное ядро алгоритма PAM на этапе BUILD''' состоит из многочисленных вычислений значений целевой функции при различных вариантах выбора дополнительного медоида (шаг алгоритма <math>1 \leq i \leq k</math>):

<math>F^i = \min_{x_{o_h} \in O_{i-1}} \sum_{j = 1}^{n} \min_{ x_{m_l} \in M_{i-1}} ( \rho ( x_{m_l},x_j ), \rho ( x_{o_h},x_j ) ) = \min_{x_{o_h} \in O_{i-1}} \sum_{j = 1}^{n} \overline{MIN}_{i, x_{o_h}}^{(j)},</math>

где:
* <math>\overline{MIN}_{1, x_{o_h} \in O_0} = \{ \rho (x_{o_h}, x_j ) \| 1 \leq j \leq n \};</math>
* <math>\overline{MIN}_{i, x_{o_h} \in O_{i-1}} = \{ \min ( \overline{MIN}_{i-1, x_{m_{i-1}}}^{(j)}, \rho (x_{o_h}, x_j) ) \| 1 \leq j \leq n \}, \forall i: 1 

С каждой итерацией количество вариантов выбора дополнительных медоидов уменьшается на единицу, таким образом, на <math>i</math>-м шаге целевую функцию нужно вычислить лишь <math>|O_{i-1}| = n-i+1</math> раз.

''Оптимизация'':

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

'''Вычислительное ядро алгоритма PAM на этапе SWAP''' состоит из многочисленных вычислений значений целевой функции при различных вариантах замены некоторого существующего медоида на элемент из числа не-медоидов. <math>i</math>-я итерация фазы SWAP:

<math>F^i = \min_{x_{m_s} \in M_{i-1} , x_{o_h} \in O_{i-1}} \sum_{j = 1}^{n} \min_{ x_{m_l} \in M_{i-1} \backslash \{x_{m_s}\} } ( \rho ( x_{m_l},x_j ), \rho ( x_{o_h},x_j) ) =</math> <math>= \min_{x_{m_s} \in M_{i-1} } \min_{x_{o_h} \in O_{i-1}} \sum_{j = 1}^{n} \min ( \min_{ x_{m_l} \in M_{i-1} \backslash \{x_{m_s}\} } ( \rho ( x_{m_l},x_j )) , \rho ( x_{o_h},x_j) )</math>

''Оптимизация'':

* таким образом, при поиске пары (медоид, не-медоид), наилучшим образом минимизирующей целевую функцию, происходит поиск минимума по всем возможным элементам <math>x_{o_h}</math>, для которых вычисляется <math>\sum_{j = 1}^{n} \min (a, b)</math>, где <math>a</math> есть <math> \min_{ x_{m_l} \in M_{i-1} \backslash \{x_{m_s}\} } ( \rho ( x_{m_l},x_j )),</math> и является инвариантом по отношению к <math>\min_{x_{o_h} \in O_{i-1}} \sum_{j = 1}^{n} \min ( \min_{ x_{m_l} \in M_{i-1} \backslash \{x_{m_s}\} } ( \rho ( x_{m_l},x_j )) , \rho ( x_{o_h},x_j) ),</math> что позволяет предвычислить элемент <math>a.</math>

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

''Опишем макрооперации алгоритма'':
* в случае если алгоритму PAM на вход подаётся набор точек с их координатами в пространстве <math>R^w,</math> то необходимо вычислить матрицу расстояний. Для этого может быть использована, например, евклидова метрика:
*: <math>\rho (p,q)=\sqrt{(p_1-q_1)^2+(p_2-q_2)^2+\dots+(p_w-q_w)^2} = \sqrt{\sum_{j=1}^w (p_j-q_j)^2} </math>, где <math>p, q \in R^w;</math>
* нахождение минимального среди значений, принимаемых некоторой функцией <math>value,</math> определённой на дискретном множестве <math>Y=\{y_i\}, \, i = \overline{(1,r)}:</math>
*: <math>minimum_{y \in Y } (value (y)) = \min \Bigg(value(y_1), \min \bigg(value(y_2), \min \Big(\dots , \min(value(y_{r-1}), value(y_{r})) ... \Big) \bigg)\Bigg);</math>
* вычисление вектора инвариантов, используемых при оптимизации фазы SWAP (см. вычислительное ядро алгоритма):
*: <math>\overline{a} = \{ minimum_{ x_{m_l} \in M_{i-1} \backslash \{x_{m_s}\} } ( \rho ( x_{m_l}, x_j ) ) \| 1 \leq j \leq n \},</math> где <math>i - </math>номер итерации;
* вычисление вектора расстояний от каждой точки заданного множества <math>X</math> до ближайшего медоида из множества <math>M_{i-1} \backslash \{x_{m_s}\},</math> где <math>i - </math>номер итерации фазы SWAP:
*: <math>\overline{b} = \{ \min (\overline{a}^{(j)}, \rho ( x_{o_p}, x_j )) \| 1 \leq j \leq n \};</math>
* сложение компонент вектора: <math>S = \sum_{j = 1}^{n} \overline{f}^{(j)}.</math>

''Макроструктура вычислительного ядра алгоритма PAM'' может быть выражена через макрооперации следующим образом:
* для ядра фазы BUILD:
*::: <math>F^i = minimum_{ x_{o_h} \in O_{i-1} } ( S \, ( \overline{f} (x_{o_h}) )),</math>
*::: <math>\overline{f} = \{ \min \,( \overline{MIN}_{i, x_{o_h}}^{(j)}, \rho (x_{o_h}, x_j)) \| 1 \leq j \leq n \}, </math> где
*# <math>S</math> вычисляется <math>n-i+1</math> раз;
*# <math>minimum</math> находится <math>1</math> раз при вычислении наилучшего значения целевой функции на текущей итерации.

* для ядра фазы SWAP:
*::: <math>F^i = minimum_{ x_{m_s} \in M_{i-1} , x_{o_h} \in O_{i-1} } ( S \, ( \overline{b} \, ( x_{o_h}, \overline{a} \, (x_{m_s}) ) )),</math> где:
*# <math>minimum</math> находится <math>n</math> раз в процессе вычисления макрооперации <math>\overline {a};</math>
*# <math>\overline {a}</math> вычисляется <math>k</math> раз и использует вычисленные на шаге 1 минимальные значения;
*# <math>\overline {b}</math> вычисляется <math>k(n-k)</math> раз и использует вычисленные на шаге 2 значения <math>\overline {a};</math>
*# <math>S</math> вычисляется <math>k(n-k)</math> раз и использует вычисленные на шаге 3 значения <math>\overline {b};</math>
*# <math>minimum</math> находится <math>1</math> раз при вычислении наилучшего значения целевой функции на текущей итерации.

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

''Псевдокод алгоритма'':

'''Вход''' : Множество объектов <math>X</math> или матрица расстояний <math>D</math>, количество кластеров <math>k</math>
'''Выход''' : Множество медоидов <math>M</math>
0 Если на вход было подано множество объектов, необходимо предварительно вычислить матрицу расстояний;
1 Инициализация множеств <math>M := \varnothing, O := X;</math>
 
// фаза BUILD
2 '''for (int i := 1; i <= k; i++)''' {
// Найти <math>x_{m_i}:</math>
{
3 Для всех <math>x_{o_h} \in O</math> вычислить <math>F_{M \cup \{x_{o_h}\}, O \backslash \{x_{o_h}\}};</math>
4 Положить <math>x_{m_i}</math> равным <math>x_{o_h}</math>, соответствующему минимальному из вычисленных <math>F;</math>
}
5 Обновить множества <math>M := M \cup \{x_{m_i}\}, O := O \backslash \{x_{m_i}\};</math>
}
// фаза SWAP
6 '''while (1)''' {
// Найти пару <math>(x_{m_s}, x_{o_h}),</math> на которой достигается оптимальная замена:
{
7 Для всех <math>x_{m_i} \in M, x_{o_j} \in O</math> вычислить <math>F^i;</math> // вычисление проводить с учётом приведённой ранее оптимизации (см. 1.3 [[#Вычислительное ядро алгоритма|Вычислительное ядро алгоритма]]);
8 Положить пару <math>(x_{m_s}, x_{o_h})</math> равной паре <math>(x_{m_i}, x_{o_j})</math>, соответствующей минимальному из вычисленных <math>F;</math>
}
9 Вычислить <math>T^i;</math> // критерий останова (см. 1.2 [[#Математическое описание алгоритма|Математическое описание алгоритма]])
10 '''if''' <math>(T^i > 0)</math> {
11 Обновить множества <math>M := M \backslash \{x_{m_s}\} \cup \{x_{o_h}\}, O := O \cup \{x_{m_s}\} \backslash \{x_{o_h}\};</math>
12 } '''else''' {
13 '''break''';
}
};

''Оптимизации'':

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

* '''Минимизация кеш-промахов'''. Матрица расстояний, к которой постоянно выполняется доступ на чтение для вычисления минимумов и их суммирования, должна храниться в памяти как матрица размера <math>n*n</math>, несмотря на то, что она симметрическая и достаточно хранить лишь половину (элементы над или под главной диагональю). Данная оптимизация потребует использования в 2 раза большего количества памяти для хранения расстояний (а это является главным расходом памяти программы, так как все остальные используемые данные являются временными (локальными для каждой операции) и представляют из себя несколько векторов длинной <math>n</math> элементов). Однако так как в данном алгоритме доступ к матрице осуществляется построчно (в [[#Вычислительное ядро алгоритма|вычислительном ядре алгоритма]] поэлементно ищутся минимумы 2-х векторов, после чего все они складываются), то в этом случае из матрицы можно будет читать данные по строкам подряд, что снижает количество кеш-промахов. Использование только половины матрицы приводит к частым промахам в кеше в связи с необходимостью загрузки части векторов по строкам, а части - по столбцам.

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

Для вычисления '''матрицы расстояний''' требуется:
* <math>\frac{n*(n-1)}{2}</math> операций вычисления расстояний;
* сложность каждой операции вычисления расстояния (для случая использования Евклидовой метрики) равна <math>2*w-1</math> операций сложения и вычитания, <math>w</math> операций возведения в квадрат (умножения) и <math>1</math> операции извлечения квадратного корня.

На основании формулы из описания '''вычислительного ядра фазы BUILD''' определим сложность выполнения всего этапа.

Обозначим:
*<math>summs</math> - операция сложения двух вещественных чисел;
*<math>mins</math> - операция нахождения минимума для двух вещественных чисел.

Тогда, количество операций равно:

<math>S = ( ( (n-1) summs ) * (n-1+1) + (n-1+1-1)mins) + \sum_{i = 2}^{k} ( ( (1 mins)*(n-1) + (n-1) summs ) * (n-i+1) + (n-i+1-1)mins) \Rightarrow</math> 
<math>
\Rightarrow S =
\begin{cases}
S(mins) = ( ( 0 ) * (n-1+1) + (n-1+1-1)mins) + \sum_{i = 2}^{k} ( ( (1 mins)*(n-1)) * (n-i+1) + (n-i+1-1)mins ) & \quad\\
S(summs) = \sum_{i = 1}^{k} ( ( (n-1) summs ) * (n-i+1) ) & \quad\\
\end{cases}
=
</math> 
: <math>
=
\begin{cases}
S(mins) = n^2(k-1) - \frac{1}{2}(nk^2 - nk) + n - k & \quad\\
S(summs) = n^2k - \frac{1}{2}(nk^2 + nk - k^2 + k ) & \quad\\
\end{cases}
</math>

Таким образом, сложность фазы BUILD есть <math>O(kn^2)</math> как по количеству найденных минимумов, так и по количеству операций сложения.

На основании формулы из описания '''вычислительного ядра фазы SWAP''' определим сложность вычисления целевой функции <math>F^i</math> с использованием оптимизации процесса нахождения минимума (см. раздел [[#Вычислительное ядро алгоритма|Вычислительное ядро алгоритма]]). Количество операций равно:

<math>S = ( ( (1 mins)*(n-1) + (n-1) summs )*(n-k) + n*((k-1-1) mins) )*k \Rightarrow</math> 
<math>
\Rightarrow S =
\begin{cases}
S(mins) = ( ((1 mins)*(n-1) )*(n-k) + n*((k-1-1) mins) )*k = kn^2 - 3nk + k^2 & \quad\\
S(summs) = ( ( (n-1) summs )*(n-k) )*k = (n-1)(n-k)k & \quad\\
\end{cases}
</math>

Таким образом, сложность одной итерации фазы SWAP есть <math>O(kn^2)</math> как по количеству найденных минимумов, так и по количеству операция сложения.

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

Основная вычислительная сложность алгоритма PAM приходится на фазу SWAP, т.к. сложность одной её итерации сопоставима со сложностью всей фазы BUILD, однако SWAP может содержать в себе огромное число итераций.

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

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

Опишем граф фазы BUILD как аналитически, так и в виде рисунка.

''Граф состоит из шести групп вершин'':

# Операция M, соответствующая '''первой''' группе вершин, осуществляет изменение множества медоидов:
#:: <math>M_{It} = M_{It-1} \cup \overline{x}_{m_{It}}, </math> где <math>\overline{x}_{m_{It}} = \overline{x}_{o_{It}}.</math>
#: Единственная координата <math>It</math> (номер итерации), соответствующая каждой из вершин, меняется в диапазоне <math>[1; k],</math> принимая все целочисленные значения.
#: Аргументами операции являются:
#:* <math>\overline{x}_{o_{It}}</math> - результат срабатывания операции, соответствующей вершине из пятой группы с координатой <math>It,</math>
#:* <math>M_{It-1}</math> - множество медоидов:
#:** при <math>It = 1 </math> - входное данное алгоритма;
#:** при <math>1< It \leq k </math> - результат срабатывания операции, соответствующей вершине из первой группы с координатой <math>It-1.</math>
#: Результат срабатывания операции является:
#:* при <math>It < k </math> - ''промежуточным данным'' алгоритма;
#:* при <math>It = k </math> - ''выходным данным'' фазы BUILD.
#:
#: 
#:
# Операция O, соответствующая '''второй''' группе вершин, осуществляет изменение множества не-медоидов:
#:: <math>O_{It} = O_{It-1} \backslash \overline{x}_{o_{It}}.</math>
#: Единственная координата <math>It</math>, соответствующая каждой из вершин, меняется в диапазоне <math>[1; k],</math> принимая все целочисленные значения.
#: Аргументами операции являются:
#:* <math>\overline{x}_{o_{It}}</math> - результат срабатывания операции, соответствующей вершине из пятой группы с координатой <math>It,</math>
#:* <math>O_{It-1}</math> - множество не-медоидов:
#:** при <math>It = 1 </math> - входное данное алгоритма;
#:** при <math>1< It \leq k </math> - результат срабатывания операции, соответствующей вершине из второй группы с координатой <math>It-1.</math>
#: Результат срабатывания операции является:
#:* при <math>It < k </math> - ''промежуточным данным'' алгоритма;
#:* при <math>It = k </math> - ''выходным данным'' фазы BUILD.
#:
#: 
#:
# Операция, соответствующая '''третьей''' группе вершин, выглядит следующим образом:
#:: <math>\overline{c}=\overline{c}_{x_{o_p} } = \begin{cases} \{ \rho (x_{o_p}, x_j ) \| 1 \leq j \leq n \}, It=1 & \quad\\ \{ \min ( \overline{MIN}^{(j)}, \rho (x_{o_p}, x_j) ) \| 1 \leq j \leq n \}, 1<It \leq k & \quad\\ \end{cases} .</math>
#: Координаты вершин:
#:* <math>It</math> - меняется в диапазоне <math>[1; k],</math> принимая все целочисленные значения;
#:* <math>p</math> - меняется в диапазоне <math>[1; n-It+1],</math> принимая все целочисленные значения.
#: Аргументами операции являются:
#:* при <math>It = 1:</math>
#:** <math>\overline{x}_{o_p}</math> - входное данное алгоритма;
#:* при <math>1 < It \leq k:</math>
#:**<math>\overline{x}_{o_p}</math> - результат срабатывания операции, соответствующей вершине из второй группы с координатой <math>It-1;</math>
#:**<math>\overline{MIN}</math> - результат срабатывания операции, соответствующей вершине из шестой группы с координатой <math>It-1.</math>
#: Результат срабатывания операции является ''промежуточным данным'' алгоритма.
#:
#: 
#:
# Операция S, соответствующая '''четвертой''' группе вершин, выглядит следующим образом:
#:: <math>S = \sum_{j = 1}^{n} \overline {c}^{(j)}.</math>
#: Координаты вершин:
#:* <math>It</math> - меняется в диапазоне <math>[1; k],</math> принимая все целочисленные значения;
#:* <math>p</math> - меняется в диапазоне <math>[1; n-It+1],</math> принимая все целочисленные значения.
#: Аргументами операции являются:
#:* <math>\overline{c}_{ x_{o_p} }</math> - результат срабатывания операции, соответствующей вершине из третьей группы с координатами <math> It, p.</math>
#: Результат срабатывания операции является ''промежуточным данным'' алгоритма.
#:
#: 
#:
# Операция M1, соответствующая '''пятой''' группе вершин, выглядит следующим образом:
#:: <math>M1 = (F^{It}; x_{o_{It}}),</math> где <math> \begin{cases}
F^{It} = \min_{x_{o_p} \in O_{It-1}} S & \quad\\
x_{o_{It}} = \arg F^{It} & \quad\\
\end{cases}</math>
#: Координаты вершин:
#:* <math>It</math> - меняется в диапазоне <math>[1; k],</math> принимая все целочисленные значения.
#: Аргументами операции являются:
#:* <math>S</math> - результаты срабатывания операций, соответствующих вершинам из четвертой группы с первой координатой <math>It,</math> всего <math>n-It+1</math> величина.
#: Результат срабатывания операции является:
#:* при <math>It < k </math> - ''промежуточным данным'' алгоритма;
#:* при <math>It = k </math> - ''выходным данным'' фазы BUILD.
#:
#: 
#:
# Операция MIN, соответствующая '''шестой''' группе вершин, выглядит следующим образом:
#:: <math>\overline{MIN}=\overline{MIN}_{It,x_{m_{It}} } = \begin{cases}
\{ \rho (x_{m_{It} }, x_j ) \| 1 \leq j \leq n \}, It=1 & \quad\\
\{ \min ( \overline{MIN}^{(j)}, \rho (x_{m_{It}}, x_j) ) \| 1 \leq j \leq n \}, 1<It \leq k & \quad\\
\end{cases}</math>
#: Координаты вершин:
#:* <math>It</math> - меняется в диапазоне <math>[1; k-1],</math> принимая все целочисленные значения.
#: Аргументами операции являются:
#:* <math>\overline{MIN}_{It-1,x_{m_{It-1}}} </math> - результат срабатывания операции, соответствующей вершине из шестой группы с координатой <math>It-1;</math>
#:* <math>x_{m_{It}} = x_{o_{It}} </math> - результат срабатывания операции, соответствующей вершине из пятой группы с координатой <math>It.</math>
#: Результат срабатывания операции является ''промежуточным данным'' алгоритма.

Описанный граф в общем случае представлен на Рис.1, отображен шаг с номером <math>It, 1<It<k</math> фазы BUILD.
Обозначения:
# вершины первой группы обозначены фиолетовым цветом и подписаны как <math>M;</math>
# вершины второй группы обозначены синим цветом и подписаны как <math>O;</math>
# вершины третьей группы обозначены жёлтым цветом и подписаны как <math>\overline{c}_{x_{o_p} };</math>
# вершины четвертой группы обозначены серым цветом и подписаны как <math>S;</math>
# вершины пятой группы обозначены зеленым цветом и подписаны как <math>M1;</math>
# вершины шестой группы обозначены красным цветом и подписаны как <math>MIN;</math>
# синим дугам сопоставлены метки, отражающие данные, используемые в соответствующих жёлтых вершинах.

[[file:Pam build 1.png|thumb|center|800px|Рисунок 1. Граф фазы BUILD алгоритма.]]

На Рис.2 представлен граф фазы BUILD для случая <math>n=6, k=3.</math> Вершины, соответствующие операциям, получающим входные данные и производящим выходные данные, увеличены и выделены толстыми границами.

[[file:Pam build 2.png|thumb|center|1100px|Рисунок 2. Граф фазы BUILD алгоритма для n = 6, k = 3. ]]

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

Опишем граф фазы SWAP как аналитически, так и в виде рисунка.

''Граф состоит из семи групп вершин'':

# Операция M, соответствующая '''первой''' группе вершин, осуществляет изменение множества медоидов.
#: Единственная координата <math>It</math> (номер итерации), соответствующая каждой из вершин, меняется в диапазоне <math>[1; T),</math> принимая все целочисленные значения, где:
#:: <math>T\in \N</math> - количество выполнений фазы SWAP во время работы алгоритма PAM.
#: Аргументами операции являются:
#:* результат срабатывания операции, соответствующей вершине из седьмой группы с координатой <math>It,</math>
#:* <math>M_{It-1}</math> - множество медоидов:
#:** при <math>It = 1 </math> - результат выполнения фазы BUILD;
#:** при <math>1< It < T </math> - результат срабатывания операции, соответствующей вершине из первой группы с координатой <math>It-1.</math>
#: Результат срабатывания операции является:
#:* при <math>It < T -1 </math> - ''промежуточным данным'' алгоритма;
#:* при <math>It = T - 1</math> - ''выходным данным'' фазы SWAP.
#:
#: 
#:
# Операция O, соответствующая '''второй''' группе вершин, осуществляет изменение множества не-медоидов.
#: Единственная координата <math>It</math>, соответствующая каждой из вершин, меняется в диапазоне <math>[1; T),</math> принимая все целочисленные значения, где:
#:: <math>T\in \N</math> - количество выполнений фазы SWAP во время работы алгоритма PAM.
#: Аргументами операции являются:
#:* результат срабатывания операции, соответствующей вершине из седьмой группы с координатой <math>It,</math>
#:* <math>O_{It-1}</math> - множество не-медоидов:
#:** при <math>It = 1 </math> - результат выполнения фазы BUILD;
#:** при <math>1< It < T </math> - результат срабатывания операции, соответствующей вершине из второй группы с координатой <math>It-1.</math>
#: Результат срабатывания операции является ''промежуточным данным'' алгоритма.
#:
#: 
#:
# Операция, соответствующая '''третьей''' группе вершин, выглядит следующим образом:
#:: <math>\overline{a}=\overline{a}_{x_{m_i} } = \{ \min_{ x_{m_l} \in M \backslash \{x_{m_i}\} } \rho ( x_{m_l},x_j ) \| 1 \leq j \leq n \}.</math>
#: Координаты вершин:
#:* <math>It</math> - меняется в диапазоне <math>[1; T],</math> принимая все целочисленные значения;
#:* <math>i</math> - меняется в диапазоне <math>[1; k],</math> принимая все целочисленные значения.
#: Аргументом операции является <math>\overline{x}_{m_i}:</math>
#:* при <math>It = 1</math> - результат выполнения фазы BUILD;
#:* при <math>It > 1</math> - результат срабатывания операции, соответствующей вершине из первой группы с координатой <math>It-1.</math>
#: Результат срабатывания операции является ''промежуточным данным'' алгоритма.
#:
#: 
#:
# Операция, соответствующая '''четвертой''' группе вершин, выглядит следующим образом:
#:: <math>\overline{b}=\overline{b}_{x_{m_i} x_{o_p} } = \{ \min (\overline{a}_{ x_{m_i}}^{(j)}, \rho ( x_{o_p},x_j )) \| 1 \leq j \leq n \}.</math>
#: Координаты вершин:
#:* <math>It</math> - меняется в диапазоне <math>[1; T],</math> принимая все целочисленные значения;
#:* <math>i</math> - меняется в диапазоне <math>[1; k],</math> принимая все целочисленные значения;
#:* <math>p</math> - меняется в диапазоне <math>[1; n-k],</math> принимая все целочисленные значения.
#: Аргументами операции являются:
#:* <math>\overline{x}_{o_p}:</math>
#:** при <math>It = 1</math> - результат выполнения фазы BUILD;
#:** при <math>It > 1</math> - результат срабатывания операции, соответствующей вершине из второй группы с координатой <math>It-1</math>
#:* <math>\overline{a}_{x_{m_i}}</math> - результат срабатывания операции, соответствующей вершине из третьей группы с координатами <math>It, i.</math>
#: Результат срабатывания операции является ''промежуточным данным'' алгоритма.
#:
#: 
#:
# Операция S, соответствующая '''пятой''' группе вершин, выглядит следующим образом:
#:: <math>S = \sum_{j = 1}^{n} \overline {b}^{(j)}.</math>
#: Координаты вершин:
#:* <math>It</math> - меняется в диапазоне <math>[1; T],</math> принимая все целочисленные значения;
#:* <math>i</math> - меняется в диапазоне <math>[1; k],</math> принимая все целочисленные значения;
#:* <math>p</math> - меняется в диапазоне <math>[1; n-k],</math> принимая все целочисленные значения.
#: Аргументами операции являются:
#:* <math>\overline{b}_{x_{m_i} x_{o_p} }</math> - результат срабатывания операции, соответствующей вершине из четвертой группы с координатами <math>It, i, p.</math>
#: Результат срабатывания операции является ''промежуточным данным'' алгоритма.
#:
#: 
#:
# Операция M1, соответствующая '''шестой''' группе вершин, выглядит следующим образом:
#:: <math>M1 = (F_{x_{o_p}}^{It}; x_{o_p}),</math> где <math> \begin{cases}
F_{x_{o_p}}^{It} = \min_{x_{o_p} \in O} S & \quad\\
x_{o_p} = \arg F_{x_{o_p}}^{It} & \quad\\
\end{cases}</math>
#: Координаты вершин:
#:* <math>It</math> - меняется в диапазоне <math>[1; T],</math> принимая все целочисленные значения;
#:* <math>i</math> - меняется в диапазоне <math>[1; k],</math> принимая все целочисленные значения.
#: Аргументами операции являются:
#:* <math>S</math> - результаты срабатывания операций, соответствующих вершинам из пятой группы с первыми двумя координатами <math>It, i,</math> всего <math>n-k</math> величин.
#: Результат срабатывания операции является ''промежуточным данным'' алгоритма.
#:
#: 
#:
# Операция M2, соответствующая '''седьмой''' группе вершин, выглядит следующим образом:
#:: <math>M2 = (F_{x_{o_p}, x_{m_i}}^{It}; x_{m_i}; x_{o_p}),</math> где <math>\begin{cases}
F_{x_{o_p}, x_{m_i}}^{It} = \min (\min_{x_{m_i} \in M} (F_{x_{o_p}}^{It}), M2_{It-1}) & \quad\\
x_{m_i} = \arg \min_{x_{m_i} \in M} M1 & \quad\\
\end{cases}</math>
#: Координаты вершин:
#:* <math>It</math> - меняется в диапазоне <math>[1; T],</math> принимая все целочисленные значения.
#: Аргументами операции являются:
#:* <math>M1 = (F_{x_{o_p}}^{It}; x_{o_p})</math> - результаты срабатывания операций, соответствующих вершинам из шестой группы с координатами <math>It, i,</math> всего <math>k</math> величин;
#:* <math>M2_{It-1}:</math>
#:** при <math>It = 1</math> - результат выполнения фазы BUILD;
#:** при <math>It > 1</math> - результаты срабатывания операции, соответствующей вершине из седьмой группы с координатой <math>It-1;</math>
#: Результат срабатывания операции является:
#:* при <math>It < T</math> - ''промежуточным данным'' алгоритма;
#:* при <math>It = T</math> - ''выходным данным'' фазы SWAP.

Описанный граф в общем случае представлен на Рис.3, отображена одна итерация фазы SWAP.
Обозначения:
# вершины первой группы обозначены фиолетовым цветом и подписаны как <math>M;</math>
# вершины второй группы обозначены синим цветом и подписаны как <math>O;</math>
# вершины третьей группы обозначены желтым цветом и подписаны как <math>\overline{a}_{x_{m_i} };</math>
# вершины четвертой группы обозначены оранжевым цветом и подписаны как <math>\overline{b}_{x_{m_i o_p} };</math>
# вершины пятой группы обозначены серым цветом и подписаны как <math>S;</math>
# вершины шестой группы обозначены зеленым цветом и подписаны как <math>M1;</math>
# вершины седьмой группы обозначены красным цветом и подписаны как <math>M2;</math>
# синим дугам сопоставлены метки, отражающие данные, используемые в соответствующих оранжевых вершинах;
# фиолетовым дугам сопоставлены метки, отражающие данные, используемые в соответствующих жёлтых вершинах.

[[file:Pam swap 1.png|thumb|center|1100px|Рисунок 3. Граф фазы SWAP алгоритма.]]

На Рис.4 представлен граф фазы SWAP для случая <math>n=6, k=2, T=3.</math> Вершины, соответствующие операциям, получающим входные данные и производящим выходные данные, увеличены и выделены толстыми границами.

[[file:Pam swap 2.png|thumb|center|1100px|Рисунок 4. Граф фазы SWAP алгоритма для n = 6, k = 2, T = 3.]]

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

При параллельной реализации алгоритма PAM будем рассматривать параллельные варианты фазы BUILD и SWAP ([[#Возможная параллельная реализация алгоритма PAM|возможная параллельная реализация]]). Покажем, что сложность фазы BUILD сопоставима со сложностью одной итерации фазы SWAP.

Оценки последовательной сложности фаз BUILD и SWAP приведены в параграфе "[[#Последовательная сложность алгоритма|Последовательная сложность алгоритма]]".

==== Ресурс параллелизма фазы BUILD ====

Для решения задачи кластеризации методом PAM в параллельном варианте фазы BUILD в предположении доступности неограниченного числа процессов для одной итерации необходимо выполнить:
* 1 ярус с нахождением <math>\overline{c}:</math>
** <math>n</math> операций нахождения минимального из двух элементов при <math>It > 1</math>;
* 1 ярус с нахождением суммы <math>S:</math>
** <math>n-1</math> операцию сложения;
* 1 ярус с нахождением значений элемента <math>M1:</math>
** <math>n-It</math> операций нахождения минимального из двух элементов;
* 1 ярус с нахождением минимального элемента <math>\overline{MIN}:</math>
** <math>n</math> операций нахождения минимального из двух элементов при <math>It>1;</math>
* 1 ярус с изменением множеств медоидов и не-медоидов (не выполняются операции рассматриваемых типов).

Таким образом, параллельная сложность одного шага фазы BUILD равна:
* <math>n-1</math> операция сложения;
* <math>n-It</math> операций нахождения минимального из двух элементов при <math>It=1;</math>
* <math>3n-It</math> операций нахождения минимального из двух элементов при <math>It>1.</math>

Параллельная сложность фазы BUILD при числе кластеров <math>k</math> равна:
* <math>kn-k</math> операция сложения;
* <math>3kn - 2n - \frac{1}{2}k^2 - \frac{1}{2}k</math> операций нахождения минимального из двух элементов.

В параллельном варианте, по сравнению с последовательным, при <math>k, n \to \infty</math> количество операций на один порядок меньше по параметру <math>n:</math>

:<math>O(kn)</math> против <math>O(kn^2).</math>

Соотношение количества сложений и взятий минимума для фазы BUILD является постоянным и стремится к <math>3,</math> при <math>k, n \to \infty.</math>

Максимальная ширина яруса достигается при вычислении <math>\overline {c}</math> и <math>S</math> и равна <math>n-It+1</math> для шага <math>It</math> фазы BUILD. Максимальная ширина яруса при рассмотрении всей фазы есть <math>n</math> и достигается на первом шаге.

==== Ресурс параллелизма фазы SWAP ====

Для решения задачи кластеризации методом PAM в параллельном варианте фазы SWAP в предположении доступности неограниченного числа процессов для одной итерации необходимо выполнить:
* 1 ярус с нахождением <math>\overline {a}:</math>
** <math>n(k-1)</math> операций нахождения минимального из двух элементов;
* 1 ярус с нахождением <math>\overline {b}:</math>
** <math>n</math> операций нахождения минимального из двух элементов;
* 1 ярус с нахождением суммы <math>S</math>:
** <math>n-1</math> операцию сложения;
* 1 ярус с нахождением минимального элемента 'первого' вида <math>(M1 = \min_{x_{o_p} \in O} S):</math>
** <math>n-k-1</math> операцию нахождения минимального из двух элементов;
* 1 ярус с нахождением минимального элемента 'второго' вида <math>(M2 = \min_{x_{m_i} \in M} M1):</math>
** <math>k-1</math> операцию нахождения минимального из двух элементов;
* 1 ярус с изменением множеств медоидов и не-медоидов (не выполняются операции рассматриваемых типов).

Таким образом, параллельная сложность одной итерации фазы SWAP равна:
* <math>n-1</math> - по количеству операций сложения;
* <math>kn + n - 2</math> - по количеству операций нахождений минимума для двух чисел.

В параллельном варианте, по сравнению с последовательным, при <math>k, n \to \infty</math> количество операций на один порядок меньше по параметру <math>n:</math>
: <math>O(kn)</math> против <math>O(kn^2).</math>

Соотношение количества сложений и взятий минимума для одной итерации фазы SWAP является постоянным и равным <math>k,</math> при <math>n \to \infty</math>.

Максимальная ширина яруса достигается при вычислении <math>\overline {b}</math> и <math>S</math> и равна <math>k(n-k).</math>

При использовании выбранной модели, в предположении доступности неограниченного числа вычислителей, фаза BUILD при <math>n \to \infty</math> требует большего количества операций суммирования на порядок <math>k</math>, по сравнению с одной итерацией фазы SWAP. В свою очередь, количество операций подсчёта минимума ассимптотически эквивалентны.

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

''Входные данные'':
* число <math>n</math> - количество точек упорядоченного множества <math>X;</math>
* число <math>k</math> - количество требуемых кластеров;
* <math>n</math> векторов, состоящих из <math>n-1</math> вещественных чисел, - попарных расстояний между элементами из множества <math>X</math> за исключением расстояний вида <math>\rho (x, x)=0, x \in X;</math>
''Объём входных данных'': <math>n(n-1)</math> вещественное число и <math>2</math> целых числа.

''Структура хранения данных'':
* сразу после считывания входных данных составляется квадратная симметрическая матрица <math>D^{n * n}</math>, у которой каждый элемент <math>d_{ij}</math> является вещественным числом - расстоянием <math>\rho (x_i, x_j);</math>
* для множества медоидов <math>M</math> создаётся массив из <math>k</math> целых чисел - индексов принадлежащих ему элементов из множества <math>X</math>, аналогичный массив <math>n-k</math> целых чисел создаётся для множества не-медоидов <math>O;</math>
* для пересылки данных, как правило, используется тройка <math>(F_{x_{m_s}, x_{o_h}}^{i_j}; x_{m_s}; x_{o_h})</math> или пара <math>(F_{x_{o_h}}^{i_j}; x_{o_h}),</math> где:
** <math>x_{m_s}</math> - целое число, обозначающее порядковый номер элемента множества <math>X;</math>
** <math>x_{o_h}</math> - целое число, обозначающее порядковый номер элемента множества <math>X;</math>
** <math>F_{x_{m_s}, x_{o_h}}^{i_j}</math> - вещественное число, равное минимальному значению целевой функции, вычисленному в текущем контексте.

''Выходные данные'':
* <math>k</math> целых чисел, составляющих множество <math>M;</math>
* <math>1</math> вещественное число, являющееся значением целевой функции.

''Объём выходных данных'':
* <math>k</math> целых чисел и <math>1</math> вещественное.

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

Соотношение последовательной и параллельной сложности алгоритма является ''линейным'' и равным <math>n.</math>

''Вычислительная мощность'' последовательного алгоритма, как отношение числа операций к суммарному объему входных и выходных данных, равна <math>O(T*k).</math>
Вычислительная мощность параллельного алгоритма равна <math>O(T*\frac{k}{n}).</math>

Алгоритм PAM является ''менее чувствительным'' к выбросам данных, чем алгоритм k-средних. Это связано с использованием медоидов, менее подверженных влиянию таких данных.<ref> Егоров А. В., Куприянова Н. И. Особенности методов кластеризации данных // Известия Южного федерального университета. Технические науки. –2011. T. 124, № 11. –С. 174-177.</ref>

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

Алгоритм PAM ''конечен'', так как:
* количество операций фазы BUILD конечно;
* значение целевой фукнции неотрицательно и на каждой итерации фазы SWAP строго уменьшается.

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

Основные операция алгоритма PAM: сложение и нахождение минимума. Операция взятия минимума не подвержена процессу накопления ошибки. На каждой итерации алгоритма сложение производится над значениями, взятыми непосредственно из исходных данных. Таким образом, алгоритм PAM не накапливает ошибок в процессе своей работы и является ''устойчивым''.

При <math>k(n-k) \, \bmod \, p \neq 0</math> отсутствует возможность равномерно распределить задачи рассчёта <math>\overline{b}</math> между процессами. Кроме того, если <math>k \, \bmod \, p \neq 0</math>, то после их распределения для некоторых процессов окажется необходимым вычислить несколько соседних значений <math>\overline{a}.</math> Таким образом, ''равномерная'' загрузка процессов ''не всегда возможна''. Помимо этого, агрегирование данных с целью вычисления глобального минимума приводит к простою незадействованных процессов.

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

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

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

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

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

Необходимость уменьшения времени решения задачи приводит к потребности в создании паралельной реализации алгоритма. В дальнейшем будем придерживаться следующих допущений:
* возможно использование <math>p</math> процессов;
* не нарушая общности суждений, множества <math>M, O</math> - упорядоченны.

Приведённые далее возможные схемы для параллельных реализаций фазы BUILD и фазы SWAP основаны на максимально равномерном распределении задач между процессами.

===== Возможная параллельная реализация фазы BUILD =====

Главная задача заключается в распараллеливании многочисленных вычислений целевой функции на каждой итерации фазы BUILD:

<math>F^i = \min_{x_{o_h} \in O_{i-1}} F_{x_{o_h}}^i,</math> где <math>F_{x_{o_h}}^i = \sum_{j = 1}^{n} \overline{MIN}_{i, x_{o_h}}^{(j)},</math> где
: <math>\overline{MIN}_{1, x_{o_h} \in O_0} = \{ \rho (x_{o_h}, x_j ) \| 1 \leq j \leq n \};</math>
: <math>\overline{MIN}_{i, x_{o_h} \in O_{i-1}} = \{ \min ( \overline{MIN}_{i-1, x_{m_{i-1}}}^{(j)}, \rho (x_{o_h}, x_j) ) \| 1 \leq j \leq n \}, \forall i: 1 

''Схема реализации'': (далее <math>0 - номер текущей итерации)
# для каждого процесса с номером <math>j</math> <math>(0 \leq j < p):</math>
## положим:
##: <math>pos = p-(n-i+1) \, \bmod \, p;</math>
## на каждой итерации процессу необходимо вычислить <math>r_j</math> значений целевой функции для соответствующих ему элементов <math>x_{o_h}, ..., x_{o_{h+(r_j-1)}}:</math>
##: <math> r_j = \begin{cases}
\lfloor \frac{n-i+1}{p} \rfloor , 0 \leq j < pos & \quad\\
\lceil \frac{n-i+1}{p} \rceil , pos \leq j & \quad\\
\end{cases}
</math>
##: <math>h = \begin{cases}
r_j*j , 0 \leq j < pos & \quad\\
(r_j-1)*pos + (j-pos)*r_j , pos \leq j & \quad\\
\end{cases}</math> - порядковый номер <math>x_{o_h};</math>
#:
#:
# каждому процессу с номером <math>j</math> <math>(0 \leq j < p):</math>
## найти минимум среди значений целевой функции <math>F_{x_{o_h}}^i</math> для каждого из значений параметра <math>x_{o_h};</math>
##* в данном случае может быть использована оптимизация, описанная в [[#Вычислительное ядро алгоритма|вычислительном ядре алгоритма]];
## для процессов с номером <math>j \neq 0</math> переслать процессу с номером <math>0</math> пару <math>(x_{o_h}, F_{x_{o_h}}^i)</math> для всех обработанных <math>x_{o_h};</math>
#:
#:
# для процесса с номером <math>0</math>:
## принять пары от процессов <math>(0, p-1],</math> в ответ на шаг 2.2;
## найти <math>x_{o_h},</math> для которого целевая функция принимает минимальное значение, и положить <math>x_{m_i}:=x_{o_h};</math>
## вычислить <math>\overline{MIN}_{i, x_{m_i}}</math>;
## разослать пару <math>(x_{m_i}, \overline{MIN}_{i, x_{m_i}})</math> при помощи широковещательной рассылки;
#:
#:
# для каждого процесса с номером <math>j</math> <math>(0 \leq j < p):</math>
## принять пару <math>(x_{m_i}, \overline{MIN}_{i, x_{m_i}})</math> в ответ на шаг 3.4;
## скорректировать локальные копии множеств <math>M</math> и <math>O</math>, изменив принадлежность вектора <math>x_{m_i}</math>, а также обновить хранимое значение вектора <math>\overline{MIN}</math> для подготовки к следующей итерации;
## перейти к шагу 2.1.
#:
#:
После завершения <math>k</math> шагов фазы BUILD, множества <math>M</math> и <math>O</math> (одинаковые для каждого процесса согласно приведенной схеме), а так же значение целевой функции являются выходными данными фазы BUILD.

===== Возможная параллельная реализация фазы SWAP =====

Главная задача заключается в распараллеливании многократного вычисления целевой функции на каждой итерации фазы SWAP:

<math>F^i = \min_{x_{m_s} \in M_{i-1} } \min_{x_{o_h} \in O_{i-1}} \sum_{j = 1}^{n} \min ( \min_{ x_{m_l} \in M_{i-1} \backslash \{x_{m_s}\} } ( \rho ( x_{m_l},x_j )) , \rho ( x_{o_h},x_j) )</math>

''Схема реализации'': (далее <math>i \in \N</math> - номер текущей итерации)
# для каждого процесса с номером <math>j</math> <math>(0 \leq j < p):</math>
## положим:
##: <math>pos = p-(k*(n-k)) \, \bmod \, p;</math>
## на каждой итерации процессу необходимо вычислить <math>r_j</math> значений целевой функции для соответствующих ему пар вида (медоид, не-медоид) <math>(x_{m_s}, x_{o_h}), (x_{m_s}, x_{o_{h+1}}), ..., (x_{m_s}, x_{o_{n-k}}), (x_{m_{s+1}}, x_{o_0}), (x_{m_{s+1}}, x_{o_1}), . . . \, : </math>
##:<math> r_j = \begin{cases}
\lfloor \frac{k*(n-k)}{p} \rfloor , 0 \leq j < pos & \quad\\
\lceil \frac{k*(n-k)}{p} \rceil , pos \leq j & \quad\\
\end{cases}
</math>
##: <math>s = \begin{cases}
(r_j*j) \mbox{ div } (n-k) , 0 \leq j < pos & \quad\\
((r_j-1)*pos + r_j*(j-pos)) \mbox{ div } (n-k), pos \leq j & \quad\\
\end{cases}</math> - порядковый номер <math>x_{m_s};</math>
##: <math>h = \begin{cases}
(r_j*j) \, \bmod \, (n-k) , 0 \leq j < pos & \quad\\
((r_j-1)*pos + r_j*(j-pos)) \, \bmod \, (n-k), pos \leq j & \quad\\
\end{cases}</math> - порядковый номер <math>x_{o_h};</math>
#:
#:
# каждому процессу с номером <math>j</math> <math>(0 \leq j < p):</math>
## найти минимум среди вычисленных значений целевой функции для каждого из значений первого параметра <math>x_{m_s}</math> по соответствующим ему <math>x_{o_h};</math>
##* в данном случае может быть использована оптимизация, описанная в [[#Вычислительное ядро алгоритма|вычислительном ядре алгоритма]];
## переслать процессу с номером <math>N = s \, \bmod \, p</math> (если <math>N \neq j</math>) тройку <math>(F_{x_{m_s}, x_{o_h}}^{i_j}, x_{m_s}, x_{o_h})</math> для всех обработанных <math>x_{m_s};</math>
# для процессов с номерами <math>j<\min (p, k):</math>
## принять описанные выше тройки от процессов, обработавших элементы <math>x_{m_{z \, \bmod \, p = j}}, z = \overline {0, k-1},</math> в ответ на шаг 2.2;
## вычислить минимальное среди полученных значений целевой функции;
## запомнить <math>x_{m_s}</math> и <math>x_{o_h}</math>, на которых минимальное значение было достигнуто;
## при <math>j \neq 0 </math> отправить тройку <math>(F_{x_{m_s}, x_{o_h}}^{i_j}, x_{m_s}, x_{o_h})</math>, соответствующую выбранной паре, процессу с номером <math>0</math>;
# для процесса с номером <math>0</math>:
## принять тройки от процессов <math>(0, min(k-1, p-1)],</math> в ответ на шаг 3.4;
## найти пару <math>(x_{m_s}, x_{o_h})</math>, для которой целевая функция принимает минимальное значение;
## сравнить найденное минимальное значение с вычисленным значением целевой функции на предыдущей итерации фазы SWAP;
### ('' '''условие останова''' '') если значение целевой функции не уменьшилось, остановить вычисление;
### иначе, разослать выявленную пару <math>(x_{m_s}, x_{o_h})</math> при помощи широковещательной рассылки;
# для каждого процесса с номером <math>j</math> <math>(0 \leq j < p):</math>
## принять пару <math>(x_{m_s}, x_{o_h})</math> в ответ на шаг 4.3.2;
## скорректировать локальные копии множеств <math>M</math> и <math>O</math>, заменяя элемент <math>x_{m_s}</math> на элемент <math>x_{o_h}</math> и наоборот;
## перейти к шагу 2.

===== Ограничения и недостатки =====

''Ограничения'':
* предполагается, что матрица расстояний <math>D^{n * n}</math> полностью помещается в памяти каждого процесса.

''Недостатки'':
* при распределении обсчитываемых целевых функций, каждому из процессов ставится в соответствие некоторая совокупность пар <math>(x_{m_s}, x_{o_h})</math>, для которых нужно рассчитать значения целевой функции. В случае, если количество процессов не кратно количеству обрабатываемых кластеров, различные процессы получат пары у которых совпадают <math>x_{m_s}</math>, что приведёт к совершению одинаковых вычислений на различных процессах: <math> \min_{ x_{m_l} \in M_{i-1} \backslash \{x_{m_s}\} } ( \rho ( x_{m_l},x_j )), 1 \leq j \leq n;</math>
* вычисление фазы SWAP успешно распараллеливается между <math>p</math> процессами, однако после этого происходит агрегация данных в 2 этапа относительно <math>(x_{m_s}, x_{o_h})</math> для вычисления глобального минимума. На первом этапе данные собираются на первых <math>\min (p,k)</math> процессах, где происходят локальные вычисления минимумов среди принятых данных (для каждого <math>x_{m_s}</math>), после чего полученные минимумы и связанная с ними информация агрегируются на мастер-процессе, который вычисляет глобальный минимум и извещает о нём все остальные процессы. Во время описанных вычислений все незадействованные процессы простаивают.

''Дополнительные возможности'':
* помимо описанной схемы, также есть возможность распараллелить операцию вычисления матрицы расстояний <math>D</math>, однако это является отдельной алгоритмической задачей и не даёт существенного прироста производительности алгоритма.

==== Существующие параллельные реализации алгоритма PAM ====

Примером другой параллельной реализации алгоритма PAM может служить реализация в пакете SPRINT для языка R (подробнее см. [[#Существующие реализации алгоритма|существующие реализации алгоритма]]).

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

Структура графа алгоритма (см. 1.7 [[#Информационный граф| Информационный граф алгоритма]]) такова, что позволяет надеяться на получение хорошей масштабируемости.

Исследование масштабируемости параллельной реализации алгоритма Partitioning Around Medoids проводилось на суперкомпьютере BlueGene/P <ref>IBM BlueGene/P - [http://hpc.cmc.msu.ru http://hpc.cmc.msu.ru]</ref>.
Отметим, что для данному суперкомпьютеру свойственна стабильность по времени вычисления одной и той же задачи при различных запусках.
Во время вычислений каждому MPI процессу соответствовало 1 ядро процессора PowerPC 450, 850 MHz с пиковой производительностью 3.4 GFlop/sec per core.

Набор и границы значений изменяемых [[Глоссарий#Параметры запуска|параметров запуска]] реализации алгоритма:
* число процессов (p):
** [1; 4 : 512] с шагом 4 процесса;
* размер кластеризуемого множества (n):
** [4; 16; 32; 64];
** [128 : 3200] с шагом 128 элементов;
* каждому размеру кластеризуемого множества соответствует количество кластеров для разбиения (k):
** [2; 4; 4; 8];
** [2 : 50] с шагом 2.

Особенности проведения эксперимента:
* тестовые данные являются псевдослучайными;
* для всех экспериментов использовался одинаковый набор данных;
* в соответствии с описанными параметрами запуска, для множеств размерности [128 : 3200], количество кластеров (k) прямо пропорционально размеру задачи (n).

В результате проведённых экспериментов был получен широкий диапазон [[Глоссарий#Эффективность распараллеливания|эффективности реализации]] алгоритма:
* минимальная эффективность реализации: <math>3.4 * 10^{-9} \, %</math> достигается при использовании 512 процессов для множества из 4 элементов и 2-х кластеров (результат вызван избыточностью количества процессов по отношению к размеру задачи);
* максимальная эффективность реализации: <math>4.1 * 10^{-4} \, %</math> достигается при использовании 4 процессов для множества из 128 элементов и 2 кластеров.

Абсолютная величина [[Глоссарий#Производительность|производительности алгоритма]] (GFlops) определялась как количество операций с плавающей точкой за секунду. Точное количество операций было вычислено на основании [[#Последовательная сложность алгоритма| последовательной сложности алгоритма]], целочисленные операции и операции работы с памятью не учитывались.

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

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

{|style="margin: 0 auto;"
| [[file:PAM-gflops.png|thumb|none|600px|Рисунок 5а. Параллельная реализация алгоритма PAM. Изменение производительности в зависимости от числа процессов и размера множества.]]
| [[file:PAM-gflops-top-view.png|thumb|none|600px|Рисунок 5б. Параллельная реализация алгоритма PAM. Изменение производительности в зависимости от числа процессов и размера множества. Вид сверху.]]
|}


[[file:PAM-efficiency.png|thumb|center|800px|Рисунок 6. Параллельная реализация алгоритма PAM. Изменение эффективности в зависимости от числа процессов и размера множества.]]

На рисунке 5б, видно, что пики организованы в прямые. Это обусловлено инвариантностью величины <math>a</math> в соответствии с описанной в [[#Вычислительное ядро алгоритма | вычислительном ядре фазы SWAP]] оптимизацией. На рисунке 3 для [[#Информационный граф фазы SWAP| информационного графа фазы SWAP]] наглядно видно, что при построчном распределении вычислений <math>\overline{b}_{x_{m_s, o_h}}</math> возможно возникновение следующих ситуаций (далее при '' '''k * (n-k) mod p == 0''' '' обозначим '' '''r = k * (n-k) / p''' ''):
# при '' '''r < (n-k)''' '', если '' '''(n-k) mod r == 0''' '', то каждому процессу необходимо вычислить ровно одну величину <math>\overline{a}_{x_{m_s}};</math>
# при '' '''r ≥ (n-k)''' '', если '' '''k mod p == 0''' '', то каждому процессу необходимо вычислить несколько соответствующих ему величин <math>\overline{a}_{x_{m_s}},</math> при этом каждая величина будет вычислена ровно в одном процессе;
# в остальных случаях вычисления величин <math>\overline{b}_{x_{m_s, o_h}}</math> распределяются между процессами таким образом, что часть процессов обрабатывает больше величин <math>\overline{a}_{x_{m_s}}</math> нежели остальные (ситуация возникает при обработке процессом последних элементов одной строки и первых элементов следующей). Подобная ситуация приводит к дополнительным вычислениям на некоторых процессах и, как следствие, к простою остальных, в связи с чем происходит падение производительности.

Первые два случая приводят к равномерному распределению нагрузки между процессами, и им соответствуют видимые пики на приведённых рисунках 5a, 5б, 6. Для 3-го случая из-за неравномерной загрузки процессов достигаемая производительность падает.

Второй случай соответствует размеру задачи меньшему, чем количество процессов и на практике маловероятен.
Таким образом, для повышения производительности следует выбирать количество процессов так, чтобы '' '''k * (n-k)''' '' и '' '''(n-k)''' '' были кратны '' '''p''' '' и '' '''k * (n-k) div p''' '' соответственно.

Для исследуемой реализации, вычисление величин <math>\overline{a}_{x_{m_s}}</math> может быть оптимизировано (за счёт распределения между процессами и последующих пересылок). Однако принципиальный вид графиков останется тем же: пики будут наблюдаться для случаев равномерного распределения вычислительных задач между процессами.

Построим оценки масштабируемости выбранной реализации алгоритма PAM:
* По числу процессов: <math>- \, 1.6 * 10^{-8}.</math> С ростом числа процессов эффективность на рассмотренной области изменений параметров запуска уменьшается. Этот результат вызван ростом времени, затрачиваемого на пересылку данных, то есть ростом накладных расходов на организацию параллельного выполнения.
* По размеру задачи: <math>3.9 * 10^{-7}</math>. С ростом размера задачи эффективность на рассмотренной области изменений параметров запуска увеличивается. Этот результат вызван увеличением количества вычислений относительно объема пересылок данных.
* Общая оценка масштабируемости: <math>- \, 1.2 * 10^{-9}</math>. При рассмотрении области параметров запуска в целом можно говорить о том, что с ростом размера задачи и числа процессов эффективность незначительно падает.

[https://github.com/phonexicum/pam-mpi-cmc Исследованная параллельная реализация на языке C++] (реализация написана самостоятельно)

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

# Последовательная реализация алгоритма PAM в пакете ClusterR на языке R:
#* Лицензия: MIT
#* [https://cran.r-project.org/package=ClusterR веб-страница фреймворка (исходный код, системные требования и справочное руководство)]
#* Алгоритм PAM реализован в функции 'Cluster_Medoids'. Отличительная особенность реализации <ref>Lampros Mouselimis [https://cran.r-project.org/web/packages/cluster/cluster.pdf Package 'ClusterR']. October 8, 2016</ref>:
#** для задания метрики между элементами кластеризуемого множества передаётся строка, задающая одну из реализованных в алгоритме метрик. Данный подход теряет одно из преимуществ алгоритма PAM, позволяющее в качестве матрицы расстояний использовать произвольную матрицу различий.
#:
#:
# Последовательная реализация алгоритма PAM в пакете Cluster на языке R:
#* Лицензия: GPL (≥2)
#* [https://cran.r-project.org/package=cluster веб-страница фреймворка (исходный код, системные требования и справочное руководство)]
#* Алгоритм PAM реализован в функции 'pam()'. Данная реализация имеет следующие особенности <ref>Martin Maechler., etc. [https://cran.r-project.org/web/packages/cluster/cluster.pdf Package 'cluster']. October 8, 2016</ref>:
#** функция может принимать на вход не множество точек, а матрицу расстояний между ними;
#** реализация более гибкая, так как принимает на вход матрицу различий элементов, а не использует какую-либо метрику;
#** может быть предоставлено графическое отображение.
#:
#:
#:
# Параллельная реализация алгоритма PAM в пакете SPRINT (Simple Parallel R INTerface - параллельный фреймворк) на языке R:
#* Лицензия: GPL (≥3)
#* [https://cran.r-project.org/package=sprint веб-страница фреймворка (исходный код, системные требования и справочное руководство)]
#* Алгоритм PAM реализован в фукции 'ppam()'. Входные параметры данной функции схожи с параметрами, задаваемыми в линейной реализации 'pam()' пакета Cluster языка R. Отличительной особенностью является подача на вход предвычисленной матрицы расстояний (например, с помощью функции 'pcor()' из этой же библиотеки).<ref>University of Edinburgh SPRINT Team. [https://cran.r-project.org/web/packages/sprint/sprint.pdf Package 'sprint']. February 20, 2015</ref>
#:
#:
# Параллельная реализация алгоритма PAM на основе операций MapReduce на Hadoop кластере.
#* В рамках исследования по ускорению анализа информации о геноме были созданы реализации алгоритма PAM с использованием технологии MPI и технологии MapReduce. Реализация в открытом досупе отсутствует. <ref>Dobrzelecki B. et al. Managing and analysing Genomic Data using HPC and Clouds //Grid and Cloud Database Management. – Springer Berlin Heidelberg, 2011. – С. 261-277.</ref>



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

Участник:Avasilenko/Partitioning Around Medoids (PAM)

2016-11-24T08:27:03Z

Dexter:

{Assignment|Преподаватель 1|Dexter}}
{{Assignment|Zhum}}

{{algorithm
| name = Partitioning Around Medoids
| serial_complexity = <math>O(T*kn^2)</math>
| input_data = <math>n*(n-1)+2</math>
| output_data = <math>k+1</math>
| pf_height = <math>O(T*kn)</math>
| pf_width = <math>O(k(n-k))</math>
}}

'''Авторы''':
* [[Участник:Avasilenko|А.Э.Василенко]] (отвечает за программистскую составляющую);
* [[Участник:Anastasia|А.В.Тузикова]] (отвечает за математическую составляющую).
Вклад авторов считать равноценным, чётких границ ответственности провести невозможно.

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

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

Объединение схожих объектов в группы - один из важнейших видов человеческой деятельности<ref>Rousseeuw P. J., Kaufman L. Finding Groups in Data. – Wiley Online Library, 1990.</ref>. Более того - это важная часть процесса познания мира, в котором мы живем. Мы учим детей различать кошек и собак, воду и песок, мужчин и женщин путем постоянного развития и улучшения подсознательных схем классификации. Примеры есть и во взрослой жизни – в химии необходимо классифицировать соединения, в археологии – объединять находки по периодам и т.д.

'''Задача кластеризации''' - разделение множества объектов на заданное число множеств с минимизацией некоторого функционала - является популярной задачей, относится к разделу машинного обучения и находит применение в таких областях, как анализ текста, биоинформатика, интеллектуальные транспортные системы и др. <ref> Речкалов Т.В. Параллельный алгоритм кластеризации для многоядерного сопроцессора Intel Xeon Phi // Суперкомпьютерные дни в России: Труды vеждународной конференции. – М.: Изд-во МГУ, 2015, c. 532.</ref>

Существует несколько видов кластеризации<ref>Маннинг К.Д., Введение в информационный поиск: пер. с англ. / К.Д. Маннинг, П. Рагхаван, Х.Шютце - М. : Вильямс, 2011. - 528.</ref>:

* ''плоская кластеризация'' (''flat clustering'') - порождает совокупность кластеров, не имеющих явных взаимосвязей;
* ''иерархическая кластеризация'' (''hierarchical clustering'') - создаёт иерархию кластеров.

'''PAM''' ('''Partitioning Around Medoids''') - плоский алгоритм кластеризации, позволяющий выделить <math>k</math> кластеров (множеств), удовлетворяющих следующим свойствам:

* каждая группа содержит хотя бы один объект;
* каждый объект принадлежит ровно одной группе.

Модель <ref>Kaufman, L. and Rousseeuw, P.J., Clustering by means of Medoids. In: Y. Dodge and North-Holland, editor. Statistical Data Analysis Based on the L1-Norm and Related Methods. Springer US; 1987, p. 405–416.</ref>, лежащая в основе алгоритма PAM, основана на выборе <math>k</math> объектов, являющихся характерными точками соответствующего кластера. Таким образом, кластерам сопоставляются принадлежащие им объекты, называемые '''медоидами''', на основании которых распределяются остальные объекты по принципу наибольшего сходства. Cама модель называется моделью '''k-medoids''' (не путать с моделью ''k-median'').

PAM состоит из двух фаз: '''BUILD''' и '''SWAP''':

* на фазе BUILD выполняется первичная кластеризация, в ходе которой последовательно выбираются <math>k</math> объектов в качестве медоидов;
* фаза SWAP представляет собой итерационный процесс, в ходе которого производятся попытки улучшить множество медоидов. Алгоритм выполняет поиск пары объектов (медоид, не-медоид), минимизирующих целевую функцию при замене, после чего обновляет множество медоидов.

На каждой итерации алгоритма выбирается пара (медоид, не-медоид) такая, что замена медоида <math>x_{m_l}</math> на не-медоид <math>x_{o_h}</math> дает лучшую кластеризацию из возможных. Оценка кластеризации выполняется с помощью целевой функции, вычисляемой как сумма расстояний от каждого объекта до ближайшего медоида:

:<math>E = \sum_{j = 1}^n \min_{1 \leq l \leq k} \rho ( x_{m_l},x_{o_j} )</math>

Процедура изменения множества медоидов повторяется, пока есть возможность улучшения значения целевой функции.

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

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

* множество кластеризуемых объектов <math>X = \{ x_1, x_2, ... , x_n \} </math>, где <math>x_i</math> - кортеж, состоящий из <math> w </math> вещественных чисел;
* симметрическая матрица <math>D</math>, элементы матрицы <math>d_{ij}=d(i,j)</math> - вычисленные расстояния между объектами <math>x_i, x_j</math>;
* количество кластеров <math>k \leq n.</math>

''Обозначения'':
* <math>M = \{ x_{m_1}, x_{m_2}, ... , x_{m_k} \} </math> - множество медоидов, <math> M \subseteq X ;</math>
* <math>O = \{ x_{o_1}, x_{o_2}, ... , x_{o_r} \} </math> - множество не-медоидов, <math> O \subseteq X, </math> где <math>r=n-k;</math>
* <math>d_{ij}=\rho (x_i, x_j )</math>, где <math> \rho : X \times X \rightarrow R </math> — метрика расстояния;
* <math>F_{M,O} = \sum_{j = 1}^{n} \min_{ x_{m_l} \in M} \rho ( x_{m_l},x_{o_j} )</math> - значение целевой функции для заданных множеств <math>M</math> и <math>O;</math>
* <math>T^i</math> - изменение целевой функции на <math>i</math>-м шаге фазы SWAP.

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

* <math>M = \{ x_{m_1}, x_{m_2}, ... , x_{m_k} \}</math> - множество медоидов;
* <math>K_{m_i} = \{ x_{o_h} \in O \| x_{m_i} = \arg \min_{x_{m_s} \in M} \rho (x_{o_h}, x_{m_s}) \}, 1 \leq i \leq k</math> - искомые кластеры.

''Вычислительные формулы метода'':

* ''фаза BUILD'' (состоит из <math>k</math> шагов последовательного выбора <math>k</math> медоидов):
** <math>O_0 = X, M_0 = \varnothing ;</math>
** <math>x_{m_1} = \arg \min_{x_{o_h} \in O_0} \sum_{j = 1}^n \rho \left ( x_{o_h},x_j \right ), O_1 = O_0 \backslash \{x_{m_1}\}, M_1 = M_1 \cup \{x_{m_1}\} ; </math>
** <math>x_{m_2} = \arg \min_{x_{o_h} \in O_1} \sum_{j = 1}^{n} \min ( \rho ( x_{m_1},x_j ), \rho ( x_{o_h},x_j ) ), O_2 = O_1 \backslash \{x_{m_2}\}, M_2 = M_1 \cup \{x_{m_2}\} ; </math>
** <math>x_{m_3} = \arg \min_{x_{o_h} \in O_2} \sum_{j = 1}^{n} \min_{1 \leq l \leq 2} ( \rho ( x_{m_l},x_j ) , \rho ( x_{o_h},x_j ) ) , O_3 = O_2 \backslash \{x_{m_3}\}, M_3 = M_3 \cup \{x_{m_3}\} ; </math>
** ...
** <math>x_{m_k} = \arg \min_{x_{o_h} \in O_{k-1}} \sum_{j = 1}^{n} \min_{ x_{m_l} \in M_{k-1}} ( \rho ( x_{m_l},x_j ), \rho ( x_{o_h},x_j ) ) , O_k = O_{k-1} \backslash \{x_{m_k}\}, M_k = M_{k-1} \cup \{x_{m_k}\} ; </math>

* ''фаза SWAP'' (итерационный процесс):
** начальное приближение: <math>O_0 = O_k^{BUILD}, M_0 = M_k^{BUILD};</math>
** <math>i</math>-й шаг итерации:
*** вычисление целевой функции при оптимальной замене (замене, при которой достигается лучшая кластеризация из возможных на текущей итерации): <math>F^i = \min_{x_{m_s} \in M_{i-1} , x_{o_h} \in O_{i-1}} \sum_{j = 1}^{n} \min_{ x_{m_l} \in M_{i-1} \backslash \{x_{m_s}\} } ( \rho ( x_{m_l},x_j ), \rho ( x_{o_h},x_j) ); </math>
*** определение пары (медоид, не-медоид), на которой достигается оптимальная замена: <math> (x_{m_s}, x_{o_h}) = \arg F^i; </math>
*** проверка критерия останова;
*** изменение множеств в соответствии с выбранной парой <math> (x_{m_s}, x_{o_h}):</math> <math>M_i = M_{i-1} \backslash \{x_{m_s}\} \cup \{x_{o_h}\} , O_i = O_{i-1} \cup \{x_{m_s}\} \backslash \{x_{o_h}\} ;</math>
** критерий останова:
*** <math>T^i = F^{i-1} - F^{i} \leq 0 .</math>

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

'''Вычислительное ядро алгоритма PAM на этапе BUILD''' состоит из многочисленных вычислений значений целевой функции при различных вариантах выбора дополнительного медоида (шаг алгоритма <math>1 \leq i \leq k</math>):

<math>F^i = \min_{x_{o_h} \in O_{i-1}} \sum_{j = 1}^{n} \min_{ x_{m_l} \in M_{i-1}} ( \rho ( x_{m_l},x_j ), \rho ( x_{o_h},x_j ) ) = \min_{x_{o_h} \in O_{i-1}} \sum_{j = 1}^{n} \overline{MIN}_{i, x_{o_h}}^{(j)},</math>

где:
* <math>\overline{MIN}_{1, x_{o_h} \in O_0} = \{ \rho (x_{o_h}, x_j ) \| 1 \leq j \leq n \};</math>
* <math>\overline{MIN}_{i, x_{o_h} \in O_{i-1}} = \{ \min ( \overline{MIN}_{i-1, x_{m_{i-1}}}^{(j)}, \rho (x_{o_h}, x_j) ) \| 1 \leq j \leq n \}, \forall i: 1 

С каждой итерацией количество вариантов выбора дополнительных медоидов уменьшается на единицу, таким образом, на <math>i</math>-м шаге целевую функцию нужно вычислить лишь <math>|O_{i-1}| = n-i+1</math> раз.

''Оптимизация'':

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

'''Вычислительное ядро алгоритма PAM на этапе SWAP''' состоит из многочисленных вычислений значений целевой функции при различных вариантах замены некоторого существующего медоида на элемент из числа не-медоидов. <math>i</math>-я итерация фазы SWAP:

<math>F^i = \min_{x_{m_s} \in M_{i-1} , x_{o_h} \in O_{i-1}} \sum_{j = 1}^{n} \min_{ x_{m_l} \in M_{i-1} \backslash \{x_{m_s}\} } ( \rho ( x_{m_l},x_j ), \rho ( x_{o_h},x_j) ) =</math> <math>= \min_{x_{m_s} \in M_{i-1} } \min_{x_{o_h} \in O_{i-1}} \sum_{j = 1}^{n} \min ( \min_{ x_{m_l} \in M_{i-1} \backslash \{x_{m_s}\} } ( \rho ( x_{m_l},x_j )) , \rho ( x_{o_h},x_j) )</math>

''Оптимизация'':

* таким образом, при поиске пары (медоид, не-медоид), наилучшим образом минимизирующей целевую функцию, происходит поиск минимума по всем возможным элементам <math>x_{o_h}</math>, для которых вычисляется <math>\sum_{j = 1}^{n} \min (a, b)</math>, где <math>a</math> есть <math> \min_{ x_{m_l} \in M_{i-1} \backslash \{x_{m_s}\} } ( \rho ( x_{m_l},x_j )),</math> и является инвариантом по отношению к <math>\min_{x_{o_h} \in O_{i-1}} \sum_{j = 1}^{n} \min ( \min_{ x_{m_l} \in M_{i-1} \backslash \{x_{m_s}\} } ( \rho ( x_{m_l},x_j )) , \rho ( x_{o_h},x_j) ),</math> что позволяет предвычислить элемент <math>a.</math>

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

''Опишем макрооперации алгоритма'':
* в случае если алгоритму PAM на вход подаётся набор точек с их координатами в пространстве <math>R^w,</math> то необходимо вычислить матрицу расстояний. Для этого может быть использована, например, евклидова метрика:
*: <math>\rho (p,q)=\sqrt{(p_1-q_1)^2+(p_2-q_2)^2+\dots+(p_w-q_w)^2} = \sqrt{\sum_{j=1}^w (p_j-q_j)^2} </math>, где <math>p, q \in R^w;</math>
* нахождение минимального среди значений, принимаемых некоторой функцией <math>value,</math> определённой на дискретном множестве <math>Y=\{y_i\}, \, i = \overline{(1,r)}:</math>
*: <math>minimum_{y \in Y } (value (y)) = \min \Bigg(value(y_1), \min \bigg(value(y_2), \min \Big(\dots , \min(value(y_{r-1}), value(y_{r})) ... \Big) \bigg)\Bigg);</math>
* вычисление вектора инвариантов, используемых при оптимизации фазы SWAP (см. вычислительное ядро алгоритма):
*: <math>\overline{a} = \{ minimum_{ x_{m_l} \in M_{i-1} \backslash \{x_{m_s}\} } ( \rho ( x_{m_l}, x_j ) ) \| 1 \leq j \leq n \},</math> где <math>i - </math>номер итерации;
* вычисление вектора расстояний от каждой точки заданного множества <math>X</math> до ближайшего медоида из множества <math>M_{i-1} \backslash \{x_{m_s}\},</math> где <math>i - </math>номер итерации фазы SWAP:
*: <math>\overline{b} = \{ \min (\overline{a}^{(j)}, \rho ( x_{o_p}, x_j )) \| 1 \leq j \leq n \};</math>
* сложение компонент вектора: <math>S = \sum_{j = 1}^{n} \overline{f}^{(j)}.</math>

''Макроструктура вычислительного ядра алгоритма PAM'' может быть выражена через макрооперации следующим образом:
* для ядра фазы BUILD:
*::: <math>F^i = minimum_{ x_{o_h} \in O_{i-1} } ( S \, ( \overline{f} (x_{o_h}) )),</math>
*::: <math>\overline{f} = \{ \min \,( \overline{MIN}_{i, x_{o_h}}^{(j)}, \rho (x_{o_h}, x_j)) \| 1 \leq j \leq n \}, </math> где
*# <math>S</math> вычисляется <math>n-i+1</math> раз;
*# <math>minimum</math> находится <math>1</math> раз при вычислении наилучшего значения целевой функции на текущей итерации.

* для ядра фазы SWAP:
*::: <math>F^i = minimum_{ x_{m_s} \in M_{i-1} , x_{o_h} \in O_{i-1} } ( S \, ( \overline{b} \, ( x_{o_h}, \overline{a} \, (x_{m_s}) ) )),</math> где:
*# <math>minimum</math> находится <math>n</math> раз в процессе вычисления макрооперации <math>\overline {a};</math>
*# <math>\overline {a}</math> вычисляется <math>k</math> раз и использует вычисленные на шаге 1 минимальные значения;
*# <math>\overline {b}</math> вычисляется <math>k(n-k)</math> раз и использует вычисленные на шаге 2 значения <math>\overline {a};</math>
*# <math>S</math> вычисляется <math>k(n-k)</math> раз и использует вычисленные на шаге 3 значения <math>\overline {b};</math>
*# <math>minimum</math> находится <math>1</math> раз при вычислении наилучшего значения целевой функции на текущей итерации.

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

''Псевдокод алгоритма'':

'''Вход''' : Множество объектов <math>X</math> или матрица расстояний <math>D</math>, количество кластеров <math>k</math>
'''Выход''' : Множество медоидов <math>M</math>
0 Если на вход было подано множество объектов, необходимо предварительно вычислить матрицу расстояний;
1 Инициализация множеств <math>M := \varnothing, O := X;</math>
 
// фаза BUILD
2 '''for (int i := 1; i <= k; i++)''' {
// Найти <math>x_{m_i}:</math>
{
3 Для всех <math>x_{o_h} \in O</math> вычислить <math>F_{M \cup \{x_{o_h}\}, O \backslash \{x_{o_h}\}};</math>
4 Положить <math>x_{m_i}</math> равным <math>x_{o_h}</math>, соответствующему минимальному из вычисленных <math>F;</math>
}
5 Обновить множества <math>M := M \cup \{x_{m_i}\}, O := O \backslash \{x_{m_i}\};</math>
}
// фаза SWAP
6 '''while (1)''' {
// Найти пару <math>(x_{m_s}, x_{o_h}),</math> на которой достигается оптимальная замена:
{
7 Для всех <math>x_{m_i} \in M, x_{o_j} \in O</math> вычислить <math>F^i;</math> // вычисление проводить с учётом приведённой ранее оптимизации (см. 1.3 [[#Вычислительное ядро алгоритма|Вычислительное ядро алгоритма]]);
8 Положить пару <math>(x_{m_s}, x_{o_h})</math> равной паре <math>(x_{m_i}, x_{o_j})</math>, соответствующей минимальному из вычисленных <math>F;</math>
}
9 Вычислить <math>T^i;</math> // критерий останова (см. 1.2 [[#Математическое описание алгоритма|Математическое описание алгоритма]])
10 '''if''' <math>(T^i > 0)</math> {
11 Обновить множества <math>M := M \backslash \{x_{m_s}\} \cup \{x_{o_h}\}, O := O \cup \{x_{m_s}\} \backslash \{x_{o_h}\};</math>
12 } '''else''' {
13 '''break''';
}
};

''Оптимизации'':

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

* '''Минимизация кеш-промахов'''. Матрица расстояний, к которой постоянно выполняется доступ на чтение для вычисления минимумов и их суммирования, должна храниться в памяти как матрица размера <math>n*n</math>, несмотря на то, что она симметрическая и достаточно хранить лишь половину (элементы над или под главной диагональю). Данная оптимизация потребует использования в 2 раза большего количества памяти для хранения расстояний (а это является главным расходом памяти программы, так как все остальные используемые данные являются временными (локальными для каждой операции) и представляют из себя несколько векторов длинной <math>n</math> элементов). Однако так как в данном алгоритме доступ к матрице осуществляется построчно (в [[#Вычислительное ядро алгоритма|вычислительном ядре алгоритма]] поэлементно ищутся минимумы 2-х векторов, после чего все они складываются), то в этом случае из матрицы можно будет читать данные по строкам подряд, что снижает количество кеш-промахов. Использование только половины матрицы приводит к частым промахам в кеше в связи с необходимостью загрузки части векторов по строкам, а части - по столбцам.

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

Для вычисления '''матрицы расстояний''' требуется:
* <math>\frac{n*(n-1)}{2}</math> операций вычисления расстояний;
* сложность каждой операции вычисления расстояния (для случая использования Евклидовой метрики) равна <math>2*w-1</math> операций сложения и вычитания, <math>w</math> операций возведения в квадрат (умножения) и <math>1</math> операции извлечения квадратного корня.

На основании формулы из описания '''вычислительного ядра фазы BUILD''' определим сложность выполнения всего этапа.

Обозначим:
*<math>summs</math> - операция сложения двух вещественных чисел;
*<math>mins</math> - операция нахождения минимума для двух вещественных чисел.

Тогда, количество операций равно:

<math>S = ( ( (n-1) summs ) * (n-1+1) + (n-1+1-1)mins) + \sum_{i = 2}^{k} ( ( (1 mins)*(n-1) + (n-1) summs ) * (n-i+1) + (n-i+1-1)mins) \Rightarrow</math> 
<math>
\Rightarrow S =
\begin{cases}
S(mins) = ( ( 0 ) * (n-1+1) + (n-1+1-1)mins) + \sum_{i = 2}^{k} ( ( (1 mins)*(n-1)) * (n-i+1) + (n-i+1-1)mins ) & \quad\\
S(summs) = \sum_{i = 1}^{k} ( ( (n-1) summs ) * (n-i+1) ) & \quad\\
\end{cases}
=
</math> 
: <math>
=
\begin{cases}
S(mins) = n^2(k-1) - \frac{1}{2}(nk^2 - nk) + n - k & \quad\\
S(summs) = n^2k - \frac{1}{2}(nk^2 + nk - k^2 + k ) & \quad\\
\end{cases}
</math>

Таким образом, сложность фазы BUILD есть <math>O(kn^2)</math> как по количеству найденных минимумов, так и по количеству операций сложения.

На основании формулы из описания '''вычислительного ядра фазы SWAP''' определим сложность вычисления целевой функции <math>F^i</math> с использованием оптимизации процесса нахождения минимума (см. раздел [[#Вычислительное ядро алгоритма|Вычислительное ядро алгоритма]]). Количество операций равно:

<math>S = ( ( (1 mins)*(n-1) + (n-1) summs )*(n-k) + n*((k-1-1) mins) )*k \Rightarrow</math> 
<math>
\Rightarrow S =
\begin{cases}
S(mins) = ( ((1 mins)*(n-1) )*(n-k) + n*((k-1-1) mins) )*k = kn^2 - 3nk + k^2 & \quad\\
S(summs) = ( ( (n-1) summs )*(n-k) )*k = (n-1)(n-k)k & \quad\\
\end{cases}
</math>

Таким образом, сложность одной итерации фазы SWAP есть <math>O(kn^2)</math> как по количеству найденных минимумов, так и по количеству операция сложения.

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

Основная вычислительная сложность алгоритма PAM приходится на фазу SWAP, т.к. сложность одной её итерации сопоставима со сложностью всей фазы BUILD, однако SWAP может содержать в себе огромное число итераций.

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

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

Опишем граф фазы BUILD как аналитически, так и в виде рисунка.

''Граф состоит из шести групп вершин'':

# Операция M, соответствующая '''первой''' группе вершин, осуществляет изменение множества медоидов:
#:: <math>M_{It} = M_{It-1} \cup \overline{x}_{m_{It}}, </math> где <math>\overline{x}_{m_{It}} = \overline{x}_{o_{It}}.</math>
#: Единственная координата <math>It</math> (номер итерации), соответствующая каждой из вершин, меняется в диапазоне <math>[1; k],</math> принимая все целочисленные значения.
#: Аргументами операции являются:
#:* <math>\overline{x}_{o_{It}}</math> - результат срабатывания операции, соответствующей вершине из пятой группы с координатой <math>It,</math>
#:* <math>M_{It-1}</math> - множество медоидов:
#:** при <math>It = 1 </math> - входное данное алгоритма;
#:** при <math>1< It \leq k </math> - результат срабатывания операции, соответствующей вершине из первой группы с координатой <math>It-1.</math>
#: Результат срабатывания операции является:
#:* при <math>It < k </math> - ''промежуточным данным'' алгоритма;
#:* при <math>It = k </math> - ''выходным данным'' фазы BUILD.
#:
#: 
#:
# Операция O, соответствующая '''второй''' группе вершин, осуществляет изменение множества не-медоидов:
#:: <math>O_{It} = O_{It-1} \backslash \overline{x}_{o_{It}}.</math>
#: Единственная координата <math>It</math>, соответствующая каждой из вершин, меняется в диапазоне <math>[1; k],</math> принимая все целочисленные значения.
#: Аргументами операции являются:
#:* <math>\overline{x}_{o_{It}}</math> - результат срабатывания операции, соответствующей вершине из пятой группы с координатой <math>It,</math>
#:* <math>O_{It-1}</math> - множество не-медоидов:
#:** при <math>It = 1 </math> - входное данное алгоритма;
#:** при <math>1< It \leq k </math> - результат срабатывания операции, соответствующей вершине из второй группы с координатой <math>It-1.</math>
#: Результат срабатывания операции является:
#:* при <math>It < k </math> - ''промежуточным данным'' алгоритма;
#:* при <math>It = k </math> - ''выходным данным'' фазы BUILD.
#:
#: 
#:
# Операция, соответствующая '''третьей''' группе вершин, выглядит следующим образом:
#:: <math>\overline{c}=\overline{c}_{x_{o_p} } = \begin{cases} \{ \rho (x_{o_p}, x_j ) \| 1 \leq j \leq n \}, It=1 & \quad\\ \{ \min ( \overline{MIN}^{(j)}, \rho (x_{o_p}, x_j) ) \| 1 \leq j \leq n \}, 1<It \leq k & \quad\\ \end{cases} .</math>
#: Координаты вершин:
#:* <math>It</math> - меняется в диапазоне <math>[1; k],</math> принимая все целочисленные значения;
#:* <math>p</math> - меняется в диапазоне <math>[1; n-It+1],</math> принимая все целочисленные значения.
#: Аргументами операции являются:
#:* при <math>It = 1:</math>
#:** <math>\overline{x}_{o_p}</math> - входное данное алгоритма;
#:* при <math>1 < It \leq k:</math>
#:**<math>\overline{x}_{o_p}</math> - результат срабатывания операции, соответствующей вершине из второй группы с координатой <math>It-1;</math>
#:**<math>\overline{MIN}</math> - результат срабатывания операции, соответствующей вершине из шестой группы с координатой <math>It-1.</math>
#: Результат срабатывания операции является ''промежуточным данным'' алгоритма.
#:
#: 
#:
# Операция S, соответствующая '''четвертой''' группе вершин, выглядит следующим образом:
#:: <math>S = \sum_{j = 1}^{n} \overline {c}^{(j)}.</math>
#: Координаты вершин:
#:* <math>It</math> - меняется в диапазоне <math>[1; k],</math> принимая все целочисленные значения;
#:* <math>p</math> - меняется в диапазоне <math>[1; n-It+1],</math> принимая все целочисленные значения.
#: Аргументами операции являются:
#:* <math>\overline{c}_{ x_{o_p} }</math> - результат срабатывания операции, соответствующей вершине из третьей группы с координатами <math> It, p.</math>
#: Результат срабатывания операции является ''промежуточным данным'' алгоритма.
#:
#: 
#:
# Операция M1, соответствующая '''пятой''' группе вершин, выглядит следующим образом:
#:: <math>M1 = (F^{It}; x_{o_{It}}),</math> где <math> \begin{cases}
F^{It} = \min_{x_{o_p} \in O_{It-1}} S & \quad\\
x_{o_{It}} = \arg F^{It} & \quad\\
\end{cases}</math>
#: Координаты вершин:
#:* <math>It</math> - меняется в диапазоне <math>[1; k],</math> принимая все целочисленные значения.
#: Аргументами операции являются:
#:* <math>S</math> - результаты срабатывания операций, соответствующих вершинам из четвертой группы с первой координатой <math>It,</math> всего <math>n-It+1</math> величина.
#: Результат срабатывания операции является:
#:* при <math>It < k </math> - ''промежуточным данным'' алгоритма;
#:* при <math>It = k </math> - ''выходным данным'' фазы BUILD.
#:
#: 
#:
# Операция MIN, соответствующая '''шестой''' группе вершин, выглядит следующим образом:
#:: <math>\overline{MIN}=\overline{MIN}_{It,x_{m_{It}} } = \begin{cases}
\{ \rho (x_{m_{It} }, x_j ) \| 1 \leq j \leq n \}, It=1 & \quad\\
\{ \min ( \overline{MIN}^{(j)}, \rho (x_{m_{It}}, x_j) ) \| 1 \leq j \leq n \}, 1<It \leq k & \quad\\
\end{cases}</math>
#: Координаты вершин:
#:* <math>It</math> - меняется в диапазоне <math>[1; k-1],</math> принимая все целочисленные значения.
#: Аргументами операции являются:
#:* <math>\overline{MIN}_{It-1,x_{m_{It-1}}} </math> - результат срабатывания операции, соответствующей вершине из шестой группы с координатой <math>It-1;</math>
#:* <math>x_{m_{It}} = x_{o_{It}} </math> - результат срабатывания операции, соответствующей вершине из пятой группы с координатой <math>It.</math>
#: Результат срабатывания операции является ''промежуточным данным'' алгоритма.

Описанный граф в общем случае представлен на Рис.1, отображен шаг с номером <math>It, 1<It<k</math> фазы BUILD.
Обозначения:
# вершины первой группы обозначены фиолетовым цветом и подписаны как <math>M;</math>
# вершины второй группы обозначены синим цветом и подписаны как <math>O;</math>
# вершины третьей группы обозначены жёлтым цветом и подписаны как <math>\overline{c}_{x_{o_p} };</math>
# вершины четвертой группы обозначены серым цветом и подписаны как <math>S;</math>
# вершины пятой группы обозначены зеленым цветом и подписаны как <math>M1;</math>
# вершины шестой группы обозначены красным цветом и подписаны как <math>MIN;</math>
# синим дугам сопоставлены метки, отражающие данные, используемые в соответствующих жёлтых вершинах.

[[file:Pam build 1.png|thumb|center|800px|Рисунок 1. Граф фазы BUILD алгоритма.]]

На Рис.2 представлен граф фазы BUILD для случая <math>n=6, k=3.</math> Вершины, соответствующие операциям, получающим входные данные и производящим выходные данные, увеличены и выделены толстыми границами.

[[file:Pam build 2.png|thumb|center|1100px|Рисунок 2. Граф фазы BUILD алгоритма для n = 6, k = 3. ]]

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

Опишем граф фазы SWAP как аналитически, так и в виде рисунка.

''Граф состоит из семи групп вершин'':

# Операция M, соответствующая '''первой''' группе вершин, осуществляет изменение множества медоидов.
#: Единственная координата <math>It</math> (номер итерации), соответствующая каждой из вершин, меняется в диапазоне <math>[1; T),</math> принимая все целочисленные значения, где:
#:: <math>T\in \N</math> - количество выполнений фазы SWAP во время работы алгоритма PAM.
#: Аргументами операции являются:
#:* результат срабатывания операции, соответствующей вершине из седьмой группы с координатой <math>It,</math>
#:* <math>M_{It-1}</math> - множество медоидов:
#:** при <math>It = 1 </math> - результат выполнения фазы BUILD;
#:** при <math>1< It < T </math> - результат срабатывания операции, соответствующей вершине из первой группы с координатой <math>It-1.</math>
#: Результат срабатывания операции является:
#:* при <math>It < T -1 </math> - ''промежуточным данным'' алгоритма;
#:* при <math>It = T - 1</math> - ''выходным данным'' фазы SWAP.
#:
#: 
#:
# Операция O, соответствующая '''второй''' группе вершин, осуществляет изменение множества не-медоидов.
#: Единственная координата <math>It</math>, соответствующая каждой из вершин, меняется в диапазоне <math>[1; T),</math> принимая все целочисленные значения, где:
#:: <math>T\in \N</math> - количество выполнений фазы SWAP во время работы алгоритма PAM.
#: Аргументами операции являются:
#:* результат срабатывания операции, соответствующей вершине из седьмой группы с координатой <math>It,</math>
#:* <math>O_{It-1}</math> - множество не-медоидов:
#:** при <math>It = 1 </math> - результат выполнения фазы BUILD;
#:** при <math>1< It < T </math> - результат срабатывания операции, соответствующей вершине из второй группы с координатой <math>It-1.</math>
#: Результат срабатывания операции является ''промежуточным данным'' алгоритма.
#:
#: 
#:
# Операция, соответствующая '''третьей''' группе вершин, выглядит следующим образом:
#:: <math>\overline{a}=\overline{a}_{x_{m_i} } = \{ \min_{ x_{m_l} \in M \backslash \{x_{m_i}\} } \rho ( x_{m_l},x_j ) \| 1 \leq j \leq n \}.</math>
#: Координаты вершин:
#:* <math>It</math> - меняется в диапазоне <math>[1; T],</math> принимая все целочисленные значения;
#:* <math>i</math> - меняется в диапазоне <math>[1; k],</math> принимая все целочисленные значения.
#: Аргументом операции является <math>\overline{x}_{m_i}:</math>
#:* при <math>It = 1</math> - результат выполнения фазы BUILD;
#:* при <math>It > 1</math> - результат срабатывания операции, соответствующей вершине из первой группы с координатой <math>It-1.</math>
#: Результат срабатывания операции является ''промежуточным данным'' алгоритма.
#:
#: 
#:
# Операция, соответствующая '''четвертой''' группе вершин, выглядит следующим образом:
#:: <math>\overline{b}=\overline{b}_{x_{m_i} x_{o_p} } = \{ \min (\overline{a}_{ x_{m_i}}^{(j)}, \rho ( x_{o_p},x_j )) \| 1 \leq j \leq n \}.</math>
#: Координаты вершин:
#:* <math>It</math> - меняется в диапазоне <math>[1; T],</math> принимая все целочисленные значения;
#:* <math>i</math> - меняется в диапазоне <math>[1; k],</math> принимая все целочисленные значения;
#:* <math>p</math> - меняется в диапазоне <math>[1; n-k],</math> принимая все целочисленные значения.
#: Аргументами операции являются:
#:* <math>\overline{x}_{o_p}:</math>
#:** при <math>It = 1</math> - результат выполнения фазы BUILD;
#:** при <math>It > 1</math> - результат срабатывания операции, соответствующей вершине из второй группы с координатой <math>It-1</math>
#:* <math>\overline{a}_{x_{m_i}}</math> - результат срабатывания операции, соответствующей вершине из третьей группы с координатами <math>It, i.</math>
#: Результат срабатывания операции является ''промежуточным данным'' алгоритма.
#:
#: 
#:
# Операция S, соответствующая '''пятой''' группе вершин, выглядит следующим образом:
#:: <math>S = \sum_{j = 1}^{n} \overline {b}^{(j)}.</math>
#: Координаты вершин:
#:* <math>It</math> - меняется в диапазоне <math>[1; T],</math> принимая все целочисленные значения;
#:* <math>i</math> - меняется в диапазоне <math>[1; k],</math> принимая все целочисленные значения;
#:* <math>p</math> - меняется в диапазоне <math>[1; n-k],</math> принимая все целочисленные значения.
#: Аргументами операции являются:
#:* <math>\overline{b}_{x_{m_i} x_{o_p} }</math> - результат срабатывания операции, соответствующей вершине из четвертой группы с координатами <math>It, i, p.</math>
#: Результат срабатывания операции является ''промежуточным данным'' алгоритма.
#:
#: 
#:
# Операция M1, соответствующая '''шестой''' группе вершин, выглядит следующим образом:
#:: <math>M1 = (F_{x_{o_p}}^{It}; x_{o_p}),</math> где <math> \begin{cases}
F_{x_{o_p}}^{It} = \min_{x_{o_p} \in O} S & \quad\\
x_{o_p} = \arg F_{x_{o_p}}^{It} & \quad\\
\end{cases}</math>
#: Координаты вершин:
#:* <math>It</math> - меняется в диапазоне <math>[1; T],</math> принимая все целочисленные значения;
#:* <math>i</math> - меняется в диапазоне <math>[1; k],</math> принимая все целочисленные значения.
#: Аргументами операции являются:
#:* <math>S</math> - результаты срабатывания операций, соответствующих вершинам из пятой группы с первыми двумя координатами <math>It, i,</math> всего <math>n-k</math> величин.
#: Результат срабатывания операции является ''промежуточным данным'' алгоритма.
#:
#: 
#:
# Операция M2, соответствующая '''седьмой''' группе вершин, выглядит следующим образом:
#:: <math>M2 = (F_{x_{o_p}, x_{m_i}}^{It}; x_{m_i}; x_{o_p}),</math> где <math>\begin{cases}
F_{x_{o_p}, x_{m_i}}^{It} = \min (\min_{x_{m_i} \in M} (F_{x_{o_p}}^{It}), M2_{It-1}) & \quad\\
x_{m_i} = \arg \min_{x_{m_i} \in M} M1 & \quad\\
\end{cases}</math>
#: Координаты вершин:
#:* <math>It</math> - меняется в диапазоне <math>[1; T],</math> принимая все целочисленные значения.
#: Аргументами операции являются:
#:* <math>M1 = (F_{x_{o_p}}^{It}; x_{o_p})</math> - результаты срабатывания операций, соответствующих вершинам из шестой группы с координатами <math>It, i,</math> всего <math>k</math> величин;
#:* <math>M2_{It-1}:</math>
#:** при <math>It = 1</math> - результат выполнения фазы BUILD;
#:** при <math>It > 1</math> - результаты срабатывания операции, соответствующей вершине из седьмой группы с координатой <math>It-1;</math>
#: Результат срабатывания операции является:
#:* при <math>It < T</math> - ''промежуточным данным'' алгоритма;
#:* при <math>It = T</math> - ''выходным данным'' фазы SWAP.

Описанный граф в общем случае представлен на Рис.3, отображена одна итерация фазы SWAP.
Обозначения:
# вершины первой группы обозначены фиолетовым цветом и подписаны как <math>M;</math>
# вершины второй группы обозначены синим цветом и подписаны как <math>O;</math>
# вершины третьей группы обозначены желтым цветом и подписаны как <math>\overline{a}_{x_{m_i} };</math>
# вершины четвертой группы обозначены оранжевым цветом и подписаны как <math>\overline{b}_{x_{m_i o_p} };</math>
# вершины пятой группы обозначены серым цветом и подписаны как <math>S;</math>
# вершины шестой группы обозначены зеленым цветом и подписаны как <math>M1;</math>
# вершины седьмой группы обозначены красным цветом и подписаны как <math>M2;</math>
# синим дугам сопоставлены метки, отражающие данные, используемые в соответствующих оранжевых вершинах;
# фиолетовым дугам сопоставлены метки, отражающие данные, используемые в соответствующих жёлтых вершинах.

[[file:Pam swap 1.png|thumb|center|1100px|Рисунок 3. Граф фазы SWAP алгоритма.]]

На Рис.4 представлен граф фазы SWAP для случая <math>n=6, k=2, T=3.</math> Вершины, соответствующие операциям, получающим входные данные и производящим выходные данные, увеличены и выделены толстыми границами.

[[file:Pam swap 2.png|thumb|center|1100px|Рисунок 4. Граф фазы SWAP алгоритма для n = 6, k = 2, T = 3.]]

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

При параллельной реализации алгоритма PAM будем рассматривать параллельные варианты фазы BUILD и SWAP ([[#Возможная параллельная реализация алгоритма PAM|возможная параллельная реализация]]). Покажем, что сложность фазы BUILD сопоставима со сложностью одной итерации фазы SWAP.

Оценки последовательной сложности фаз BUILD и SWAP приведены в параграфе "[[#Последовательная сложность алгоритма|Последовательная сложность алгоритма]]".

==== Ресурс параллелизма фазы BUILD ====

Для решения задачи кластеризации методом PAM в параллельном варианте фазы BUILD в предположении доступности неограниченного числа процессов для одной итерации необходимо выполнить:
* 1 ярус с нахождением <math>\overline{c}:</math>
** <math>n</math> операций нахождения минимального из двух элементов при <math>It > 1</math>;
* 1 ярус с нахождением суммы <math>S:</math>
** <math>n-1</math> операцию сложения;
* 1 ярус с нахождением значений элемента <math>M1:</math>
** <math>n-It</math> операций нахождения минимального из двух элементов;
* 1 ярус с нахождением минимального элемента <math>\overline{MIN}:</math>
** <math>n</math> операций нахождения минимального из двух элементов при <math>It>1;</math>
* 1 ярус с изменением множеств медоидов и не-медоидов (не выполняются операции рассматриваемых типов).

Таким образом, параллельная сложность одного шага фазы BUILD равна:
* <math>n-1</math> операция сложения;
* <math>n-It</math> операций нахождения минимального из двух элементов при <math>It=1;</math>
* <math>3n-It</math> операций нахождения минимального из двух элементов при <math>It>1.</math>

Параллельная сложность фазы BUILD при числе кластеров <math>k</math> равна:
* <math>kn-k</math> операция сложения;
* <math>3kn - 2n - \frac{1}{2}k^2 - \frac{1}{2}k</math> операций нахождения минимального из двух элементов.

В параллельном варианте, по сравнению с последовательным, при <math>k, n \to \infty</math> количество операций на один порядок меньше по параметру <math>n:</math>

:<math>O(kn)</math> против <math>O(kn^2).</math>

Соотношение количества сложений и взятий минимума для фазы BUILD является постоянным и стремится к <math>3,</math> при <math>k, n \to \infty.</math>

Максимальная ширина яруса достигается при вычислении <math>\overline {c}</math> и <math>S</math> и равна <math>n-It+1</math> для шага <math>It</math> фазы BUILD. Максимальная ширина яруса при рассмотрении всей фазы есть <math>n</math> и достигается на первом шаге.

==== Ресурс параллелизма фазы SWAP ====

Для решения задачи кластеризации методом PAM в параллельном варианте фазы SWAP в предположении доступности неограниченного числа процессов для одной итерации необходимо выполнить:
* 1 ярус с нахождением <math>\overline {a}:</math>
** <math>n(k-1)</math> операций нахождения минимального из двух элементов;
* 1 ярус с нахождением <math>\overline {b}:</math>
** <math>n</math> операций нахождения минимального из двух элементов;
* 1 ярус с нахождением суммы <math>S</math>:
** <math>n-1</math> операцию сложения;
* 1 ярус с нахождением минимального элемента 'первого' вида <math>(M1 = \min_{x_{o_p} \in O} S):</math>
** <math>n-k-1</math> операцию нахождения минимального из двух элементов;
* 1 ярус с нахождением минимального элемента 'второго' вида <math>(M2 = \min_{x_{m_i} \in M} M1):</math>
** <math>k-1</math> операцию нахождения минимального из двух элементов;
* 1 ярус с изменением множеств медоидов и не-медоидов (не выполняются операции рассматриваемых типов).

Таким образом, параллельная сложность одной итерации фазы SWAP равна:
* <math>n-1</math> - по количеству операций сложения;
* <math>kn + n - 2</math> - по количеству операций нахождений минимума для двух чисел.

В параллельном варианте, по сравнению с последовательным, при <math>k, n \to \infty</math> количество операций на один порядок меньше по параметру <math>n:</math>
: <math>O(kn)</math> против <math>O(kn^2).</math>

Соотношение количества сложений и взятий минимума для одной итерации фазы SWAP является постоянным и равным <math>k,</math> при <math>n \to \infty</math>.

Максимальная ширина яруса достигается при вычислении <math>\overline {b}</math> и <math>S</math> и равна <math>k(n-k).</math>

При использовании выбранной модели, в предположении доступности неограниченного числа вычислителей, фаза BUILD при <math>n \to \infty</math> требует большего количества операций суммирования на порядок <math>k</math>, по сравнению с одной итерацией фазы SWAP. В свою очередь, количество операций подсчёта минимума ассимптотически эквивалентны.

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

''Входные данные'':
* число <math>n</math> - количество точек упорядоченного множества <math>X;</math>
* число <math>k</math> - количество требуемых кластеров;
* <math>n</math> векторов, состоящих из <math>n-1</math> вещественных чисел, - попарных расстояний между элементами из множества <math>X</math> за исключением расстояний вида <math>\rho (x, x)=0, x \in X;</math>
''Объём входных данных'': <math>n(n-1)</math> вещественное число и <math>2</math> целых числа.

''Структура хранения данных'':
* сразу после считывания входных данных составляется квадратная симметрическая матрица <math>D^{n * n}</math>, у которой каждый элемент <math>d_{ij}</math> является вещественным числом - расстоянием <math>\rho (x_i, x_j);</math>
* для множества медоидов <math>M</math> создаётся массив из <math>k</math> целых чисел - индексов принадлежащих ему элементов из множества <math>X</math>, аналогичный массив <math>n-k</math> целых чисел создаётся для множества не-медоидов <math>O;</math>
* для пересылки данных, как правило, используется тройка <math>(F_{x_{m_s}, x_{o_h}}^{i_j}; x_{m_s}; x_{o_h})</math> или пара <math>(F_{x_{o_h}}^{i_j}; x_{o_h}),</math> где:
** <math>x_{m_s}</math> - целое число, обозначающее порядковый номер элемента множества <math>X;</math>
** <math>x_{o_h}</math> - целое число, обозначающее порядковый номер элемента множества <math>X;</math>
** <math>F_{x_{m_s}, x_{o_h}}^{i_j}</math> - вещественное число, равное минимальному значению целевой функции, вычисленному в текущем контексте.

''Выходные данные'':
* <math>k</math> целых чисел, составляющих множество <math>M;</math>
* <math>1</math> вещественное число, являющееся значением целевой функции.

''Объём выходных данных'':
* <math>k</math> целых чисел и <math>1</math> вещественное.

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

Соотношение последовательной и параллельной сложности алгоритма является ''линейным'' и равным <math>n.</math>

''Вычислительная мощность'' последовательного алгоритма, как отношение числа операций к суммарному объему входных и выходных данных, равна <math>O(T*k).</math>
Вычислительная мощность параллельного алгоритма равна <math>O(T*\frac{k}{n}).</math>

Алгоритм PAM является ''менее чувствительным'' к выбросам данных, чем алгоритм k-средних. Это связано с использованием медоидов, менее подверженных влиянию таких данных.<ref> Егоров А. В., Куприянова Н. И. Особенности методов кластеризации данных // Известия Южного федерального университета. Технические науки. –2011. T. 124, № 11. –С. 174-177.</ref>

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

Алгоритм PAM ''конечен'', так как:
* количество операций фазы BUILD конечно;
* значение целевой фукнции неотрицательно и на каждой итерации фазы SWAP строго уменьшается.

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

Основные операция алгоритма PAM: сложение и нахождение минимума. Операция взятия минимума не подвержена процессу накопления ошибки. На каждой итерации алгоритма сложение производится над значениями, взятыми непосредственно из исходных данных. Таким образом, алгоритм PAM не накапливает ошибок в процессе своей работы и является ''устойчивым''.

При <math>k(n-k) \, \bmod \, p \neq 0</math> отсутствует возможность равномерно распределить задачи рассчёта <math>\overline{b}</math> между процессами. Кроме того, если <math>k \, \bmod \, p \neq 0</math>, то после их распределения для некоторых процессов окажется необходимым вычислить несколько соседних значений <math>\overline{a}.</math> Таким образом, ''равномерная'' загрузка процессов ''не всегда возможна''. Помимо этого, агрегирование данных с целью вычисления глобального минимума приводит к простою незадействованных процессов.

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

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

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

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

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

Необходимость уменьшения времени решения задачи приводит к потребности в создании паралельной реализации алгоритма. В дальнейшем будем придерживаться следующих допущений:
* возможно использование <math>p</math> процессов;
* не нарушая общности суждений, множества <math>M, O</math> - упорядоченны.

Приведённые далее возможные схемы для параллельных реализаций фазы BUILD и фазы SWAP основаны на максимально равномерном распределении задач между процессами.

===== Возможная параллельная реализация фазы BUILD =====

Главная задача заключается в распараллеливании многочисленных вычислений целевой функции на каждой итерации фазы BUILD:

<math>F^i = \min_{x_{o_h} \in O_{i-1}} F_{x_{o_h}}^i,</math> где <math>F_{x_{o_h}}^i = \sum_{j = 1}^{n} \overline{MIN}_{i, x_{o_h}}^{(j)},</math> где
: <math>\overline{MIN}_{1, x_{o_h} \in O_0} = \{ \rho (x_{o_h}, x_j ) \| 1 \leq j \leq n \};</math>
: <math>\overline{MIN}_{i, x_{o_h} \in O_{i-1}} = \{ \min ( \overline{MIN}_{i-1, x_{m_{i-1}}}^{(j)}, \rho (x_{o_h}, x_j) ) \| 1 \leq j \leq n \}, \forall i: 1 

''Схема реализации'': (далее <math>0 - номер текущей итерации)
# для каждого процесса с номером <math>j</math> <math>(0 \leq j < p):</math>
## положим:
##: <math>pos = p-(n-i+1) \, \bmod \, p;</math>
## на каждой итерации процессу необходимо вычислить <math>r_j</math> значений целевой функции для соответствующих ему элементов <math>x_{o_h}, ..., x_{o_{h+(r_j-1)}}:</math>
##: <math> r_j = \begin{cases}
\lfloor \frac{n-i+1}{p} \rfloor , 0 \leq j < pos & \quad\\
\lceil \frac{n-i+1}{p} \rceil , pos \leq j & \quad\\
\end{cases}
</math>
##: <math>h = \begin{cases}
r_j*j , 0 \leq j < pos & \quad\\
(r_j-1)*pos + (j-pos)*r_j , pos \leq j & \quad\\
\end{cases}</math> - порядковый номер <math>x_{o_h};</math>
#:
#:
# каждому процессу с номером <math>j</math> <math>(0 \leq j < p):</math>
## найти минимум среди значений целевой функции <math>F_{x_{o_h}}^i</math> для каждого из значений параметра <math>x_{o_h};</math>
##* в данном случае может быть использована оптимизация, описанная в [[#Вычислительное ядро алгоритма|вычислительном ядре алгоритма]];
## для процессов с номером <math>j \neq 0</math> переслать процессу с номером <math>0</math> пару <math>(x_{o_h}, F_{x_{o_h}}^i)</math> для всех обработанных <math>x_{o_h};</math>
#:
#:
# для процесса с номером <math>0</math>:
## принять пары от процессов <math>(0, p-1],</math> в ответ на шаг 2.2;
## найти <math>x_{o_h},</math> для которого целевая функция принимает минимальное значение, и положить <math>x_{m_i}:=x_{o_h};</math>
## вычислить <math>\overline{MIN}_{i, x_{m_i}}</math>;
## разослать пару <math>(x_{m_i}, \overline{MIN}_{i, x_{m_i}})</math> при помощи широковещательной рассылки;
#:
#:
# для каждого процесса с номером <math>j</math> <math>(0 \leq j < p):</math>
## принять пару <math>(x_{m_i}, \overline{MIN}_{i, x_{m_i}})</math> в ответ на шаг 3.4;
## скорректировать локальные копии множеств <math>M</math> и <math>O</math>, изменив принадлежность вектора <math>x_{m_i}</math>, а также обновить хранимое значение вектора <math>\overline{MIN}</math> для подготовки к следующей итерации;
## перейти к шагу 2.1.
#:
#:
После завершения <math>k</math> шагов фазы BUILD, множества <math>M</math> и <math>O</math> (одинаковые для каждого процесса согласно приведенной схеме), а так же значение целевой функции являются выходными данными фазы BUILD.

===== Возможная параллельная реализация фазы SWAP =====

Главная задача заключается в распараллеливании многократного вычисления целевой функции на каждой итерации фазы SWAP:

<math>F^i = \min_{x_{m_s} \in M_{i-1} } \min_{x_{o_h} \in O_{i-1}} \sum_{j = 1}^{n} \min ( \min_{ x_{m_l} \in M_{i-1} \backslash \{x_{m_s}\} } ( \rho ( x_{m_l},x_j )) , \rho ( x_{o_h},x_j) )</math>

''Схема реализации'': (далее <math>i \in \N</math> - номер текущей итерации)
# для каждого процесса с номером <math>j</math> <math>(0 \leq j < p):</math>
## положим:
##: <math>pos = p-(k*(n-k)) \, \bmod \, p;</math>
## на каждой итерации процессу необходимо вычислить <math>r_j</math> значений целевой функции для соответствующих ему пар вида (медоид, не-медоид) <math>(x_{m_s}, x_{o_h}), (x_{m_s}, x_{o_{h+1}}), ..., (x_{m_s}, x_{o_{n-k}}), (x_{m_{s+1}}, x_{o_0}), (x_{m_{s+1}}, x_{o_1}), . . . \, : </math>
##:<math> r_j = \begin{cases}
\lfloor \frac{k*(n-k)}{p} \rfloor , 0 \leq j < pos & \quad\\
\lceil \frac{k*(n-k)}{p} \rceil , pos \leq j & \quad\\
\end{cases}
</math>
##: <math>s = \begin{cases}
(r_j*j) \mbox{ div } (n-k) , 0 \leq j < pos & \quad\\
((r_j-1)*pos + r_j*(j-pos)) \mbox{ div } (n-k), pos \leq j & \quad\\
\end{cases}</math> - порядковый номер <math>x_{m_s};</math>
##: <math>h = \begin{cases}
(r_j*j) \, \bmod \, (n-k) , 0 \leq j < pos & \quad\\
((r_j-1)*pos + r_j*(j-pos)) \, \bmod \, (n-k), pos \leq j & \quad\\
\end{cases}</math> - порядковый номер <math>x_{o_h};</math>
#:
#:
# каждому процессу с номером <math>j</math> <math>(0 \leq j < p):</math>
## найти минимум среди вычисленных значений целевой функции для каждого из значений первого параметра <math>x_{m_s}</math> по соответствующим ему <math>x_{o_h};</math>
##* в данном случае может быть использована оптимизация, описанная в [[#Вычислительное ядро алгоритма|вычислительном ядре алгоритма]];
## переслать процессу с номером <math>N = s \, \bmod \, p</math> (если <math>N \neq j</math>) тройку <math>(F_{x_{m_s}, x_{o_h}}^{i_j}, x_{m_s}, x_{o_h})</math> для всех обработанных <math>x_{m_s};</math>
# для процессов с номерами <math>j<\min (p, k):</math>
## принять описанные выше тройки от процессов, обработавших элементы <math>x_{m_{z \, \bmod \, p = j}}, z = \overline {0, k-1},</math> в ответ на шаг 2.2;
## вычислить минимальное среди полученных значений целевой функции;
## запомнить <math>x_{m_s}</math> и <math>x_{o_h}</math>, на которых минимальное значение было достигнуто;
## при <math>j \neq 0 </math> отправить тройку <math>(F_{x_{m_s}, x_{o_h}}^{i_j}, x_{m_s}, x_{o_h})</math>, соответствующую выбранной паре, процессу с номером <math>0</math>;
# для процесса с номером <math>0</math>:
## принять тройки от процессов <math>(0, min(k-1, p-1)],</math> в ответ на шаг 3.4;
## найти пару <math>(x_{m_s}, x_{o_h})</math>, для которой целевая функция принимает минимальное значение;
## сравнить найденное минимальное значение с вычисленным значением целевой функции на предыдущей итерации фазы SWAP;
### ('' '''условие останова''' '') если значение целевой функции не уменьшилось, остановить вычисление;
### иначе, разослать выявленную пару <math>(x_{m_s}, x_{o_h})</math> при помощи широковещательной рассылки;
# для каждого процесса с номером <math>j</math> <math>(0 \leq j < p):</math>
## принять пару <math>(x_{m_s}, x_{o_h})</math> в ответ на шаг 4.3.2;
## скорректировать локальные копии множеств <math>M</math> и <math>O</math>, заменяя элемент <math>x_{m_s}</math> на элемент <math>x_{o_h}</math> и наоборот;
## перейти к шагу 2.

===== Ограничения и недостатки =====

''Ограничения'':
* предполагается, что матрица расстояний <math>D^{n * n}</math> полностью помещается в памяти каждого процесса.

''Недостатки'':
* при распределении обсчитываемых целевых функций, каждому из процессов ставится в соответствие некоторая совокупность пар <math>(x_{m_s}, x_{o_h})</math>, для которых нужно рассчитать значения целевой функции. В случае, если количество процессов не кратно количеству обрабатываемых кластеров, различные процессы получат пары у которых совпадают <math>x_{m_s}</math>, что приведёт к совершению одинаковых вычислений на различных процессах: <math> \min_{ x_{m_l} \in M_{i-1} \backslash \{x_{m_s}\} } ( \rho ( x_{m_l},x_j )), 1 \leq j \leq n;</math>
* вычисление фазы SWAP успешно распараллеливается между <math>p</math> процессами, однако после этого происходит агрегация данных в 2 этапа относительно <math>(x_{m_s}, x_{o_h})</math> для вычисления глобального минимума. На первом этапе данные собираются на первых <math>\min (p,k)</math> процессах, где происходят локальные вычисления минимумов среди принятых данных (для каждого <math>x_{m_s}</math>), после чего полученные минимумы и связанная с ними информация агрегируются на мастер-процессе, который вычисляет глобальный минимум и извещает о нём все остальные процессы. Во время описанных вычислений все незадействованные процессы простаивают.

''Дополнительные возможности'':
* помимо описанной схемы, также есть возможность распараллелить операцию вычисления матрицы расстояний <math>D</math>, однако это является отдельной алгоритмической задачей и не даёт существенного прироста производительности алгоритма.

==== Существующие параллельные реализации алгоритма PAM ====

Примером другой параллельной реализации алгоритма PAM может служить реализация в пакете SPRINT для языка R (подробнее см. [[#Существующие реализации алгоритма|существующие реализации алгоритма]]).

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

Структура графа алгоритма (см. 1.7 [[#Информационный граф| Информационный граф алгоритма]]) такова, что позволяет надеяться на получение хорошей масштабируемости.

Исследование масштабируемости параллельной реализации алгоритма Partitioning Around Medoids проводилось на суперкомпьютере BlueGene/P <ref>IBM BlueGene/P - [http://hpc.cmc.msu.ru http://hpc.cmc.msu.ru]</ref>.
Отметим, что для данному суперкомпьютеру свойственна стабильность по времени вычисления одной и той же задачи при различных запусках.
Во время вычислений каждому MPI процессу соответствовало 1 ядро процессора PowerPC 450, 850 MHz с пиковой производительностью 3.4 GFlop/sec per core.

Набор и границы значений изменяемых [[Глоссарий#Параметры запуска|параметров запуска]] реализации алгоритма:
* число процессов (p):
** [1; 4 : 512] с шагом 4 процесса;
* размер кластеризуемого множества (n):
** [4; 16; 32; 64];
** [128 : 3200] с шагом 128 элементов;
* каждому размеру кластеризуемого множества соответствует количество кластеров для разбиения (k):
** [2; 4; 4; 8];
** [2 : 50] с шагом 2.

Особенности проведения эксперимента:
* тестовые данные являются псевдослучайными;
* для всех экспериментов использовался одинаковый набор данных;
* в соответствии с описанными параметрами запуска, для множеств размерности [128 : 3200], количество кластеров (k) прямо пропорционально размеру задачи (n).

В результате проведённых экспериментов был получен широкий диапазон [[Глоссарий#Эффективность распараллеливания|эффективности реализации]] алгоритма:
* минимальная эффективность реализации: <math>3.4 * 10^{-9} \, %</math> достигается при использовании 512 процессов для множества из 4 элементов и 2-х кластеров (результат вызван избыточностью количества процессов по отношению к размеру задачи);
* максимальная эффективность реализации: <math>4.1 * 10^{-4} \, %</math> достигается при использовании 4 процессов для множества из 128 элементов и 2 кластеров.

Абсолютная величина [[Глоссарий#Производительность|производительности алгоритма]] (GFlops) определялась как количество операций с плавающей точкой за секунду. Точное количество операций было вычислено на основании [[#Последовательная сложность алгоритма| последовательной сложности алгоритма]], целочисленные операции и операции работы с памятью не учитывались.

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

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

{|style="margin: 0 auto;"
| [[file:PAM-gflops.png|thumb|none|600px|Рисунок 5а. Параллельная реализация алгоритма PAM. Изменение производительности в зависимости от числа процессов и размера множества.]]
| [[file:PAM-gflops-top-view.png|thumb|none|600px|Рисунок 5б. Параллельная реализация алгоритма PAM. Изменение производительности в зависимости от числа процессов и размера множества. Вид сверху.]]
|}


[[file:PAM-efficiency.png|thumb|center|800px|Рисунок 6. Параллельная реализация алгоритма PAM. Изменение эффективности в зависимости от числа процессов и размера множества.]]

На рисунке 5б, видно, что пики организованы в прямые. Это обусловлено инвариантностью величины <math>a</math> в соответствии с описанной в [[#Вычислительное ядро алгоритма | вычислительном ядре фазы SWAP]] оптимизацией. На рисунке 3 для [[#Информационный граф фазы SWAP| информационного графа фазы SWAP]] наглядно видно, что при построчном распределении вычислений <math>\overline{b}_{x_{m_s, o_h}}</math> возможно возникновение следующих ситуаций (далее при '' '''k * (n-k) mod p == 0''' '' обозначим '' '''r = k * (n-k) / p''' ''):
# при '' '''r < (n-k)''' '', если '' '''(n-k) mod r == 0''' '', то каждому процессу необходимо вычислить ровно одну величину <math>\overline{a}_{x_{m_s}};</math>
# при '' '''r ≥ (n-k)''' '', если '' '''k mod p == 0''' '', то каждому процессу необходимо вычислить несколько соответствующих ему величин <math>\overline{a}_{x_{m_s}},</math> при этом каждая величина будет вычислена ровно в одном процессе;
# в остальных случаях вычисления величин <math>\overline{b}_{x_{m_s, o_h}}</math> распределяются между процессами таким образом, что часть процессов обрабатывает больше величин <math>\overline{a}_{x_{m_s}}</math> нежели остальные (ситуация возникает при обработке процессом последних элементов одной строки и первых элементов следующей). Подобная ситуация приводит к дополнительным вычислениям на некоторых процессах и, как следствие, к простою остальных, в связи с чем происходит падение производительности.

Первые два случая приводят к равномерному распределению нагрузки между процессами, и им соответствуют видимые пики на приведённых рисунках 5a, 5б, 6. Для 3-го случая из-за неравномерной загрузки процессов достигаемая производительность падает.

Второй случай соответствует размеру задачи меньшему, чем количество процессов и на практике маловероятен.
Таким образом, для повышения производительности следует выбирать количество процессов так, чтобы '' '''k * (n-k)''' '' и '' '''(n-k)''' '' были кратны '' '''p''' '' и '' '''k * (n-k) div p''' '' соответственно.

Для исследуемой реализации, вычисление величин <math>\overline{a}_{x_{m_s}}</math> может быть оптимизировано (за счёт распределения между процессами и последующих пересылок). Однако принципиальный вид графиков останется тем же: пики будут наблюдаться для случаев равномерного распределения вычислительных задач между процессами.

Построим оценки масштабируемости выбранной реализации алгоритма PAM:
* По числу процессов: <math>- \, 1.6 * 10^{-8}.</math> С ростом числа процессов эффективность на рассмотренной области изменений параметров запуска уменьшается. Этот результат вызван ростом времени, затрачиваемого на пересылку данных, то есть ростом накладных расходов на организацию параллельного выполнения.
* По размеру задачи: <math>3.9 * 10^{-7}</math>. С ростом размера задачи эффективность на рассмотренной области изменений параметров запуска увеличивается. Этот результат вызван увеличением количества вычислений относительно объема пересылок данных.
* Общая оценка масштабируемости: <math>- \, 1.2 * 10^{-9}</math>. При рассмотрении области параметров запуска в целом можно говорить о том, что с ростом размера задачи и числа процессов эффективность незначительно падает.

[https://github.com/phonexicum/pam-mpi-cmc Исследованная параллельная реализация на языке C++] (реализация написана самостоятельно)

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

# Последовательная реализация алгоритма PAM в пакете ClusterR на языке R:
#* Лицензия: MIT
#* [https://cran.r-project.org/package=ClusterR веб-страница фреймворка (исходный код, системные требования и справочное руководство)]
#* Алгоритм PAM реализован в функции 'Cluster_Medoids'. Отличительная особенность реализации <ref>Lampros Mouselimis [https://cran.r-project.org/web/packages/cluster/cluster.pdf Package 'ClusterR']. October 8, 2016</ref>:
#** для задания метрики между элементами кластеризуемого множества передаётся строка, задающая одну из реализованных в алгоритме метрик. Данный подход теряет одно из преимуществ алгоритма PAM, позволяющее в качестве матрицы расстояний использовать произвольную матрицу различий.
#:
#:
# Последовательная реализация алгоритма PAM в пакете Cluster на языке R:
#* Лицензия: GPL (≥2)
#* [https://cran.r-project.org/package=cluster веб-страница фреймворка (исходный код, системные требования и справочное руководство)]
#* Алгоритм PAM реализован в функции 'pam()'. Данная реализация имеет следующие особенности <ref>Martin Maechler., etc. [https://cran.r-project.org/web/packages/cluster/cluster.pdf Package 'cluster']. October 8, 2016</ref>:
#** функция может принимать на вход не множество точек, а матрицу расстояний между ними;
#** реализация более гибкая, так как принимает на вход матрицу различий элементов, а не использует какую-либо метрику;
#** может быть предоставлено графическое отображение.
#:
#:
#:
# Параллельная реализация алгоритма PAM в пакете SPRINT (Simple Parallel R INTerface - параллельный фреймворк) на языке R:
#* Лицензия: GPL (≥3)
#* [https://cran.r-project.org/package=sprint веб-страница фреймворка (исходный код, системные требования и справочное руководство)]
#* Алгоритм PAM реализован в фукции 'ppam()'. Входные параметры данной функции схожи с параметрами, задаваемыми в линейной реализации 'pam()' пакета Cluster языка R. Отличительной особенностью является подача на вход предвычисленной матрицы расстояний (например, с помощью функции 'pcor()' из этой же библиотеки).<ref>University of Edinburgh SPRINT Team. [https://cran.r-project.org/web/packages/sprint/sprint.pdf Package 'sprint']. February 20, 2015</ref>
#:
#:
# Параллельная реализация алгоритма PAM на основе операций MapReduce на Hadoop кластере.
#* В рамках исследования по ускорению анализа информации о геноме были созданы реализации алгоритма PAM с использованием технологии MPI и технологии MapReduce. Реализация в открытом досупе отсутствует. <ref>Dobrzelecki B. et al. Managing and analysing Genomic Data using HPC and Clouds //Grid and Cloud Database Management. – Springer Berlin Heidelberg, 2011. – С. 261-277.</ref>



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

Обсуждение участника:Руслан/Плотностный алгоритм кластеризации

2016-11-22T08:22:08Z

Dexter:

1) В тексте нет ни одной ссылки на источники из списка литературы

2) Поясните, что значит "плотно-достижимые"

Обсуждение участника:Igor.orpanen

2016-11-22T08:14:41Z

Dexter:

'''Еще замечания'''

1) Проверьте грамматику и орфографию. Нашел, например, "максимальное расстояния"

2) Пункт 1.3 - "используется предварительные расчёты". Какие расчеты?

3) Поясните, что такое "k-d tree, r-tree и vantage-point tree", упомянутые несколько раз

'''Замечания к оформлению статьи:'''

0. Если рисунок не ваш, то требуется указать ссылку на ресурс, откуда он был взят.

1. В пункте 1.3 расшифруйте фразу: "построение специальных структур данных".

3. Пункт 1.5 стоит подписать комментарии к блоку псевдокода.

4. В пункте 1.7 написать пояснение к информационным графам и сделать их более подробными (особенно требуется расписать более подробно оранжевые блоки).

5. Вычислительная мощность не приведена. (см. пример: https://algowiki-project.org/ru/%D0%A0%D0%B0%D0%B7%D0%BB%D0%BE%D0%B6%D0%B5%D0%BD%D0%B8%D0%B5_%D0%A5%D0%BE%D0%BB%D0%B5%D1%86%D0%BA%D0%BE%D0%B3%D0%BE_(%D0%BC%D0%B5%D1%82%D0%BE%D0%B4_%D0%BA%D0%B2%D0%B0%D0%B4%D1%80%D0%B0%D1%82%D0%BD%D0%BE%D0%B3%D0%BE_%D0%BA%D0%BE%D1%80%D0%BD%D1%8F)

Обсуждение участника:Igor.orpanen

2016-11-22T08:14:09Z

Dexter:

'''Еще замечания'''

1) Проверьте грамматику и орфографию. Нашел, например, "максимальное расстояния"

2) Пункт 1.3 - "используется предварительные расчёты". Какие расчеты?

3) Поясните, что такое "k-d tree, r-tree и vantage-point tree", упомянутые несколько раз

Замечания к оформлению статьи:

0. Если рисунок не ваш, то требуется указать ссылку на ресурс, откуда он был взят.

1. В пункте 1.3 расшифруйте фразу: "построение специальных структур данных".

3. Пункт 1.5 стоит подписать комментарии к блоку псевдокода.

4. В пункте 1.7 написать пояснение к информационным графам и сделать их более подробными (особенно требуется расписать более подробно оранжевые блоки).

5. Вычислительная мощность не приведена. (см. пример: https://algowiki-project.org/ru/%D0%A0%D0%B0%D0%B7%D0%BB%D0%BE%D0%B6%D0%B5%D0%BD%D0%B8%D0%B5_%D0%A5%D0%BE%D0%BB%D0%B5%D1%86%D0%BA%D0%BE%D0%B3%D0%BE_(%D0%BC%D0%B5%D1%82%D0%BE%D0%B4_%D0%BA%D0%B2%D0%B0%D0%B4%D1%80%D0%B0%D1%82%D0%BD%D0%BE%D0%B3%D0%BE_%D0%BA%D0%BE%D1%80%D0%BD%D1%8F)

Обсуждение участника:Igor.orpanen

2016-11-22T08:13:29Z

Dexter:

Еще замечания
1) Проверьте грамматику и орфографию. Нашел, например, "максимальное расстояния"

2) Пункт 1.3 - "используется предварительные расчёты". Какие расчеты?

3) Поясните, что такое "k-d tree, r-tree и vantage-point tree", упомянутые несколько раз

Замечания к оформлению статьи:

0. Если рисунок не ваш, то требуется указать ссылку на ресурс, откуда он был взят.

1. В пункте 1.3 расшифруйте фразу: "построение специальных структур данных".

3. Пункт 1.5 стоит подписать комментарии к блоку псевдокода.

4. В пункте 1.7 написать пояснение к информационным графам и сделать их более подробными (особенно требуется расписать более подробно оранжевые блоки).

5. Вычислительная мощность не приведена. (см. пример: https://algowiki-project.org/ru/%D0%A0%D0%B0%D0%B7%D0%BB%D0%BE%D0%B6%D0%B5%D0%BD%D0%B8%D0%B5_%D0%A5%D0%BE%D0%BB%D0%B5%D1%86%D0%BA%D0%BE%D0%B3%D0%BE_(%D0%BC%D0%B5%D1%82%D0%BE%D0%B4_%D0%BA%D0%B2%D0%B0%D0%B4%D1%80%D0%B0%D1%82%D0%BD%D0%BE%D0%B3%D0%BE_%D0%BA%D0%BE%D1%80%D0%BD%D1%8F)

Участник:Антон Тодуа/Partitioning Around Medoids (PAM)

2016-11-18T14:51:25Z

Dexter:

{{Assignment|Преподаватель 1|Dexter}}
{{Assignment|Zhum}}

{{algorithm
| name = Partitioning Around Medoids
| serial_complexity = <math>O(Q * K * N^2)</math>
| input_data = <math>\frac{N (N - 1)}{2}</math>
| output_data = <math>K</math> медоидов или <math>N</math> кластеров объектов
| pf_height = <math>O(Q * K * N)</math>
| pf_width = <math>O(K * (N - K))</math>
}}

'''Авторы''':
* [[Участник:Антон Тодуа | Тодуа А.Р.]] (оценки и реализация)
* [[Участник:Гусева_Юлия | Гусева Ю.В.]] (описание алгоритма)
Вклад авторов следует считать равноценным.

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

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

Алгоритм ''PAM'' (Partitioning Around Medoids) был предложен Чарли Кауфаманом (Charlie Kaufman) и Питером Русивом (Peter Rousseeuw) в 1987<ref>Kaufman, L. and P.J. Rousseeuw, Clustering by means of medoids, in: Y. Dodge (Ed.), Statistical Data Analysis based on the L1 Norm (North-Holland, Amsterdam, 1987) 405 — 416.</ref>. Алгоритм является одним из распространённых вариантов реализации <math>k</math>-medoids.

''PAM'' используется для выполнения кластеризации[https://en.wikipedia.org/wiki/Hierarchical_clustering] объектов — процесса автоматического разбиения некоторого множества объектов на кластеры (множества) на основе их схожести (наиболее схожие объекты, как правило, располагаются в одном кластере). В качестве исходных данных алгоритму необходима симметрическая матрица с нолями на главной диагонали (dissimilarity matrix), задающая расстояние (в смысле похожести) между объектами, для которых выполняется кластеризация и число кластеров, по которым следует распределить объекты. Стоит отметить, что не все алгоритмы кластеризации требует задания количества кластеров, например, методы иерархической[https://en.wikipedia.org/wiki/Hierarchical_clustering] кластеризации свободны от данного ограничения.

Алгоритм ''PAM'' для каждого кластера в качестве его характерного представителя выбирает наиболее подходящий из объектов кластеризации. Выбранные объекты называются медоидами (medoids). Алгоритм состоит из двух стадий. Первая стадия – ''BUILD'' предназначена для выбора исходного множества медоидов. Вторая стадия – ''SWAP'' является итерационной. На каждой итерации стадии ''SWAP'' алгоритм пытается улучшить выбранное множество медоидов с помощью выполнения операции ''обмена'', которая представляет собой замену одного медоида на один из объектов кластеризации. Алгоритм завершает свою работу, когда ни один из возможных обменов не позволяет улучшить разбиение на кластеры. Часто на практике, условием завершения работы алгоритма также является момент, когда наилучшее возможное улучшение кластеризации меньше заранее выбранной пороговой величины. Введение данной величины позволяет сократить число итераций. Последнее, однако, снижает качество кластеризации (иногда незначительно).

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

В качестве исходных данных алгоритм принимает:
* Симметрическую матрицу <math>D</math> порядка <math>N</math> с нолями на главной диагонали для <math>N</math> объектов кластеризации: <math>i</math>-я строка матрицы <math>D</math> определяет расстояние от <math>i</math>-го объекта до каждого из остальных объектов
* Требуемое число кластеров <math>K</math>, при этом: <math>K < N</math>

Для заданных входных данных, алгоритм выбирает <math>K</math> объектов - медоидов (medoids) из <math>N</math> объектов кластеризации. Все медоиды относится к разных кластерам и являются их характерными представителями. Кластеры остальных объектов (не медоидов) совпадают с кластером ближайшего к ним медоида. Ближайший к <math>i</math>-му объекту медоид будем коротко назвать медоидом <math>i</math>-го объекта. Выбор медоидов осуществляется исходя из минимизации среднего расстояния (average dissimilarity) между объектами внутри одного кластера. От минимизации среднего расстояния можно перейти к минимизации суммы расстояний от объектов до их медоидов. Такой переход не повлияет на выбор медоидов, но позволит не накапливать ошибки округления, возникающие в результате операции деления. Стоит отметить, что в общем случае расстояние между объектами следует понимать как меру похожести (similarity) объектов.

Для дальнейшего описания алгоритма введём следующие обозначения:
* <math>U</math> – множество объектов кластеризации, не выбранных в качестве медоидов
* <math>S</math> – множество объектов кластеризации, выбранных в качестве медоидов
* <math>C_{ij}</math> – изменение расстояния от <math>j</math>-го объекта до его медоида в результате выбора <math>i</math>-го объекта в качестве медоида
* <math>T_{ijh}</math> – изменение расстояния от <math>j</math>-го объекта до его медоида, в результате ''обмена'' <math>i</math>-го медоида на <math>h</math>-й объект

Под ''обменом'' <math>i</math>-го медоида на <math>h</math>-й объект будем понимать операцию, в результате которой <math>i</math>-й медоид перестаёт быть медоидом, а <math>h</math>-й объект выбирается в качестве медоида:
:<math>
\begin{align}
S & = S - \{i\} + \{h\} \\
U & = U - \{h\} + \{i\}
\end{align}
</math>

Перед выполнением алгоритма множество <math>U</math>содержит все объекты кластеризации, а множество <math>S</math> – пусто. Описание значений <math>C_{ij}</math> и <math>T_{ijh}</math> и способа их вычисления будет дано при описании макроструктуры алгоритма.

Выполнение алгоритма включает в себя подготовительную стадию ''BUILD'' и итерационную стадию ''SWAP''.

'''Стадия ''BUILD''''' предназначена для построения начального множества медоидов и состоит в последовательном выполнении следующих шагов:

1. Добавить в множество <math>S</math> объект, сумма расстояний от которого до всех остальных объектов минимальна (самый центральный объект):
<math>S = S + \{ arg\min_{i \in U} \sum_{j \in U} d_{ij} \}</math>

2. Выбрать ещё <math>K-1</math> медоидов следующим образом
<math>S = S + \{ arg\max_{i \in U} \sum_{j \in U - \{i\}} C_{ij} \}</math>

'''Стадия ''SWAP''''' является итерационной, одна итерация состоит в попытке улучшить кластеризацию путём выполнения ''обмена''. На каждой итерации выполняется операция <math>arg\min_{i \in S, h \in U} \sum_{j \in U + \{i\}} T_{ijh}</math>. Если для найденной пары <math>i \in S</math> и <math>h \in U</math> значение <math>\sum_{j \in U + \{i\}} T_{ijh}</math> меньше ноля (это означает, что кластеризацию можно улучшить), то выполняется обмен <math>i</math>-го медоида и <math>h</math>-го объекта. В противном случае дальнейшее улучшение кластеризации с помощью ''обмена'' невозможно и алгоритм завершает свою работу.

В результате работы алгоритма множество <math>S</math> будет содержать ровно <math>K</math> объектов – медоидов. Как было сказано <math>j</math>-й объект лежит в том же кластере, что и его медоид: <math>arg\min_{i \in S} d_{ij}</math>

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

Из математического описания алгоритма следует, что [[глоссарий#Вычислительное ядро|''вычислительное ядро'']] алгоритма сосредоточено в итерационной стадии ''SWAP''. Одна итерация состоит в вычислении:
<math>arg\min_{i \in S, h \in U} \sum_{j \in U + \{i\}} T_{ijh}</math>

Смысл этого выражения в том, что выполняется выбор такой пары медоида <math>i</math> и объекта <math>h</math> операция обмена которых приведёт к улучшению кластеризации или же делается вывод о невозможности такого обмена и работа алгоритма завершается.

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

Для описания значений <math>C_{ij}</math> и <math>T_{ijh}</math> и способа их вычисления введём следующие обозначения (в дополнение к обозначениям, введённым в математическом описании алгоритма):
* <math>D_{i}</math> – расстояние от <math>i</math>-го объекта до его медоида
* <math>E_{i}</math> – расстояние от <math>i</math>-го объекта до второго ближайшего к нему медоида

Очевидно, что для любых объектов верно неравенство <math>D_{i} <= E_{i}</math>. Отметим также, что значения <math>D_{i}</math> и <math>E_{i}</math> могут меняться при изменениях в множествах <math>U</math> и <math>S</math>, следовательно они должны пересчитываться после добавления нового медоида или выполнения операции ''обмена''.

Значение <math>C_{ij}</math> представляет собой число, на которое уменьшается значение <math>D_{j}</math> в результате выбора <math>i</math>-го объекта в качестве медоида. Очевидно, что данное значение всегда неотрицательно. Для вычисления <math>C_{ij}</math> следует рассмотреть два случая. В первом случае, когда <math>D_{j} <= d_{ij}</math>, величина <math>D_{j}</math> не изменится, т.к. ближайший к <math>j</math>-му объекту медоид останется на том же расстоянии от него, следовательно будет справедливо равенство <math>C_{ij} = 0</math>. Во втором случае, когда <math>D_{j} > d_{ij}</math>, ближайшим к <math>j</math>-му объекту медоидом станет новый выбранный медоид (<math>i</math>-ый объект), следовательно будет справедливо равенство <math>C_{ij} = D_{j} - d_{ij}</math>.
[[file:PAM_Cij.png|thumb|center|300px|Вычисление значения <math>C_{ij}</math>]]

Значение <math>T_{ijh}</math> представляет собой число, которое добавляется к значению <math>D_{j}</math> в результате выполнения операции ''обмена'' <math>i</math>-го медоида и <math>h</math>-го объекта. Для вычисления <math>C_{ij}</math> следует рассмотреть два случая. В первом случае, когда <math>D_{j} = d_{ij}</math> (<math>i</math>-й объект является медоидом <math>j</math>-го объекта) может быть два варианта: <math>E_{j} <= d_{jh}</math> (медоидом <math>j</math>-го объекта станет второго ближайший к нему медоид), тогда справедливо равенство <math>T_{ijh} = E_{j} - D_{j}</math> и <math>E_{j} > d_{jh}</math> (медоидом <math>j</math>-го объекта станет <math>h</math>-й объект), тогда справедливо равенство <math>T_{ijh} = d_{jh} - D_{j}</math>. Во втором случае, когда <math>D_{j} != d_{ij}</math> (<math>i</math>-й объект НЕ является медоидом <math>j</math>-го объекта) также может быть два варианта: <math>D_{j} <= d_{jh}</math> (медоид <math>j</math>-го объекта не изменится), тогда справедливо равенство <math>T_{ijh} = 0</math> и <math>D_{j} > d_{jh}</math> (медоидом <math>j</math>-го объекта станет <math>h</math>-й объект), тогда справедливо равенство <math>T_{ijh} = d_{jh} - D_{j}</math>. Таким образом, в первом случае (<math>i</math>-й объект является медоидом <math>j</math>-го объекта) значение <math>T_{ijh}</math> может быть вычислено по формуле <math>T_{ijh} = min(E_{j}, d_{jh}) - D_{j}</math>, а во втором (<math>i</math>-й объект НЕ является медоидом <math>j</math>-го объекта) – по формуле <math>T_{ijh} = min(d_{jh} - D_{j}, 0)</math>. В формулах выше <math>min(x, y)</math> – это операция получения минимального из двух значений <math>x</math> и <math>y</math>.
[[file:PAM_Tijh.png|thumb|center|550px|Вычисление значения <math>T_{ijh}</math>]]

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

В соответствии с математическим описанием алгоритм включает две стадии ''BUILD'' и ''SWAP''. Рассмотрим реализацию каждой стадии. При описании реализации последовательного алгоритма на псевдокоде будем считать, что в программе поддерживаются следующие переменные:
<math>d_{ij}</math> – расстояние между <math>i</math>-м и <math>j</math>-м объектами
<math>K</math> – требуемое число кластеров
<math>O</math> – множество всех объектов
<math>S</math> – множество медоидов
<math>U</math> – множество всех объектов, кроме медоидов <math>U = O - S</math>
<math>D_{i}</math> – расстояние от <math>i</math>-го объекта до его медоида
<math>E_{i}</math> – расстояние от <math>i</math>-го объекта до второго ближайшего к нему медоида

Значения <math>D_{i}</math> и <math>E_{i}</math> необходимо поддерживать для вычисления значений <math>C_{ij}</math> и <math>T_{ijh}</math>.

Реализация стадии ''BUILD'':
Найти первый медоид <math>m</math> как <math>arg\min_{i \in U} \sum_{j \in U} d_{ij}</math>
Инициализировать <math>S</math> как множество из одного объекта <math>m</math>
Инициализировать <math>U</math> как множество всех объектов, кроме объекта <math>m</math>
Выполнить тело цикла <math>K-1</math> раз
Начало тела цикла
Найти следующий медоид <math>m</math> как <math>arg\max_{i \in U} \sum_{j \in U - \{i\}} C_{ij}</math>
Добавить к <math>S</math> объект <math>m</math>
Убрать из <math>U</math> объект <math>m</math>
Конец тела цикла

Реализация стадии ''SWAP'':
Инициализировать флаг ''продолжить_счёт'' значением ''истина''
Выполнить цикл с предусловием пока флаг ''продолжить_счёт'' имеет значение ''истина''
Начало тела цикла
Вычислить значения <math>D_{i}, E_{i}</math> для всех объектов из множества <math>U</math>
Вычислить пару <math>i</math> и <math>h</math>: <math>arg\min_{i \in S, h \in U} \sum_{j \in U + \{i\}} T_{ijh}</math>
Если <math>\sum_{j \in U + \{i\}} T_{ijh} < 0</math>, то выполнить обмен:
Добавить в <math>S</math> объект <math>h</math> и убрать объект <math>i</math>
Добавить в <math>U</math> объект <math>i</math> и убрать объект <math>h</math>
Иначе
Присвоить флагу ''продолжить_счёт'' значением ''ложь''
Конец тела цикла

Реализация алгоритма в соответствии с данной схемой доступа на github[https://github.com/al-pacino/Clustering].

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

При описании последовательной сложности будем считать, что выполняется распределение <math>N</math> объектов по <math>K</math> кластерам.
В соответствии с приведённым математическим описанием алгоритм включает в себя подготовительную стадию ''BUILD'' и итерационную стадию ''SWAP''.

Стадия ''BUILD'' сводится к вычислению:
Одной операции <math>arg\min_{i} \sum_{j} d_{ij}</math>
<math>K-1</math> операций <math>arg\max_{i \in U} \sum_{j \in U - \{i\}} C_{ij}</math>

Т.е. стадия ''BUILD'' требует:
<math>K * N^2</math> операций сложения
<math>K * N</math> операций сравнения (определения максимума/минимума)
Около <math>K * N^2</math> вычислений <math>C_{ij}</math>

Одна итерация стадии ''SWAP'' сводится к вычислению:
<math>arg\min_{i \in S, h \in U} \sum_{j \in U + \{i\}} T_{ijh}</math>

Т.е. одна итерации стадии ''SWAP'' требует порядка:
<math>K * N^2</math> операций сложения
<math>K * N</math> операций сравнения (определения максимума/минимума)
<math>K * (N - K) * (N - K - 1)</math> вычислений <math>T_{ijh}</math>

Вычисления <math>C_{ij}</math> и <math>T_{ijh}</math> имеют константную сложность для любых <math>i</math>, <math>j</math> и <math>h</math>, поэтому сложность одной итерации алгоритма определяется как <math>O(K * N^2)</math>. Таким образом можно отнести алгоритм ''PAM'' к алгоритмам с квадратичной сложностью по количеству <math>N</math> объектов.

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

На рисунке 1.7.1 показан информационный граф для итерации стадии ''SWAP''. Опишем его аналитически. Нетрудно видеть, что граф состоит из <math>K * N</math> групп, представляющих собой сумму <math>N</math> элементов. Суммы из разных групп не связаны между собой и в следствие этого могут быть вычислены параллельно на разных ядрах. Данное свойство хорошо отражает параллельную структуру алгоритма.

[[file:PAM_graph_swap.png|thumb|center|600px|Рисунок 1.7.1. Информационный граф одной итерации стадии ''SWAP'']]

На рисунке 1.7.2 показан информационный граф для выбора медоида на стадии ''BUILD''. Его описание практически полностью совпадает с описанием графа для итерации стадии ''SWAP'', за исключением того, что он содержит всего <math>N</math> групп сумм <math>N</math> элементов.

[[file:PAM_graph_build.png|thumb|center|600px|Рисунок 1.7.2. Информационный граф выбора медоида стадии ''BUILD'']]

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

Исходя из предположения неограниченности ресурсов будем считать, что в нашем распоряжении имеется <math>N * K</math> вычислительных ядер, память каждого из которых целиком содержит матрицу расстояния <math>D</math>.

Стадия ''BUILD'' состоит из выбора начального (центрального) медоида и выбора <math>K - 1</math> оставшихся медоидов. Для выбора медоида требуется вычисления <math>arg\max_{i \in U} \sum_{j \in U - \{i\}} C_{ij}</math> (<math>arg\min_{i \in U} \sum_{j \in U} d_{ij}</math>) для всех не выбранных объектов (из множества <math>U</math>). Сумму в операции <math>arg\max</math> (<math>arg\min</math>) можно считать независимо на разных ядрах, поэтому сложность выбора одного медоида на стадии ''BUILD'' можно сократить с <math>O(N^2)</math> до <math>O(N)</math> (сложность вычисления суммы на одном ядре). Выбор одного медоида на стадии ''BUILD'' осуществляется <math>K</math> раз, следовательно, сложность параллельной реализации стадии ''BUILD'' (в соответствии с данным описанием) будет равна <math>O(K * N)</math>. Также стоит отметить, что для выполнения стадии ''BUILD'' описанным выше образом, достаточно задействовать лишь <math>N</math> вычислительных ядер, а не <math>N * K</math>.

Проведём аналогичные рассуждения для одной итерации стадии ''SWAP''. Выполнение одной итерации требует вычисления <math>arg\min_{i \in S, h \in U} \sum_{j \in U + \{i\}} T_{ijh}</math> для каждой пары медоида и объекта. Сумму в операции <math>arg\min</math> можно считать независимо на разных ядрах, поэтому сложность одной итерации стадии ''SWAP'' можно сократить с <math>O(K * N^2)</math> до <math>O(N)</math> если задействовать <math>N * K</math> вычислительных ядер. Если в нашем распоряжении есть только <math>N</math> вычислительных ядер, то сложность операции одной итерации стадии ''SWAP'' будет равна <math>O(K * N)</math>.

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

Выполнение стадии ''BUILD'' состоит из <math>K</math> шагов.
Выполнение шага с номером <math>Step = 1,2,...,K</math> включает следующие ярусы канонической ярусно-параллельной формы:
При <math>Step = 1</math>:
1. <math>N - 1</math> операций сложения
2. <math>N - 1</math> операций минимума двух чисел

Максимальная ширину равную <math>N</math> имеет 1 ярус.

При <math>Step > 1</math>:
1. <math>N - Step</math> операций вычитания
2. <math>N - Step</math> операций максимума
3. <math>N - Step</math> операций сложения
4. <math>N - Step</math> операций максимума
5. Добавление нового медоида (не требует выполнения рассматриваемых операций)

Максимальную ширину равную <math>N - Step + 1</math> имеют ярусы 1, 2 и 3.

Таким образом, параллельная сложность стадии ''BUILD'' включает:
<math>2*N*K - K^2 - N - K + 1</math> операций сложения (вычитания)
<math>2*N*K - K^2 - N - K + 1</math> операций максимума (минимума)

Выполнение одной итерации стадии ''SWAP'' включает следующие ярусы канонической ярусно-параллельной формы:
1. <math>N - K + 1</math> операций минимума
2. <math>N - K + 1</math> операций вычитания
3. <math>N - K</math> операций сложения
4. <math>K * (N - K) - 1</math> операций минимума
5. Выполнение операции ''обмена'' (не требует выполнения рассматриваемых операций)

Максимальную ширину равную <math>K * (N - K)</math> имеют ярусы 1, 2 и 3.

Таким образом, параллельная сложность стадии ''SWAP'' включает:
<math>2*N - 2*K + 1</math> операций сложения (вычитания)
<math>N*K + N - K + 1</math> операций максимума (минимума)

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

1. Матрица расстояния (в смысле непохожести) между объектами кластеризации (dissimilarity matrix) <math>D</math> (элементы <math>d_{ij}</math>).
Дополнительные ограничения:
<math>D</math> – симметрическая матрица порядка <math>N</math>, т.е. <math>d_{ij}= d_{ji}, i, j = 1, \ldots, N</math>
<math>D</math> – содержит нули на главной диагонали, т.е. <math>d_{ii}= 0, i = 1, \ldots, N</math>
2. <math>K</math> - число кластеров, на которое следует разбить объекты кластеризации

'''Объём входных данных''':
<math>\frac{N (N - 1)}{2}</math> (в силу симметричности и нулевой главной диагонали достаточно хранить только над/поддиагональные элементы). В разных реализациях эта экономия хранения может быть выполнена разным образом.

'''Выходные данные''':
<math>N</math> чисел <math>k_{1}, k_{2}, \ldots, k_{N}</math>, где <math>k_{i}</math> - целое число, соответствующее кластеру <math>i</math>-го объекта.

Выходными данными алгоритма также можно считать <math>K</math> чисел, задающих номера объектов кластеризации, выделенных в качестве медоидов (medoids). Однако в большинстве случаев требуется именно определение кластеров объектов, а не поиск соответствующих медоидов.

'''Объём выходных данных''':
<math>N</math> (кластеры объектов)

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

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

При описании [[глоссарий#Вычислительная мощность|''вычислительной мощности'']] будем считать, что для завершения работы алгоритма ''PAM'' требуется выполнить <math>Q</math> итераций стадии ''SWAP''.

Последовательная [[глоссарий#Вычислительная мощность|''вычислительная мощность'']] как стадии ''BUILD'' так и одной итерации стадии ''SWAP'' равна <math>O(K)</math>. Следовательно, последовательная [[глоссарий#Вычислительная мощность|''вычислительная мощность'']] алгоритма равна <math>O(Q * K)</math>.

Параллельная [[глоссарий#Вычислительная мощность|''вычислительная мощность'']] стадии ''BUILD'' и одной итерации стадии ''SWAP'', в случае когда используется <math>N</math> вычислительных узлов, равна <math>O(\frac{K}{N})</math>. В случае когда используется <math>N * K</math> вычислительных узлов для одной итерации стадии ''SWAP'' это значение снижается до <math>O(\frac{1}{N})</math>. Следовательно, параллельная [[глоссарий#Вычислительная мощность|''вычислительная мощность'']] алгоритма равна <math>O(\frac{Q * K}{N})</math>, в случае когда используется <math>N</math> вычислительных узлов, и <math>O(\frac{Q + K}{N})</math>, в случае когда используется <math>N * K</math> вычислительных узлов.

<table border="1" cellspacing="0" cellpadding="8" style="text-align: center;">
<caption>Таблица 1.10.1. [[глоссарий#Вычислительная мощность|''Вычислительная мощность'']] алгоритма</caption>
<tr style="background-color: #dedede;">
<th>'''[[глоссарий#Вычислительная мощность|''Вычислительная мощность'']]'''</th>
<th>'''Последовательной реализации'''</th>
<th>'''Параллельной реализации (<math>N</math> вычислительных узлов)'''</th>
<th>'''Параллельной реализации (<math>N * K</math> вычислительных узлов)'''</th>
</tr>
<tr>
<td>Стадии ''BUILD''</td>
<td><math>O(K)</math></td>
<td><math>O(\frac{K}{N})</math></td>
<td><math>O(\frac{K}{N})</math></td>
</tr>
<tr>
<td>Одной итерации стадии ''SWAP''</td>
<td><math>O(K)</math></td>
<td><math>O(\frac{K}{N})</math></td>
<td><math>O(\frac{1}{N})</math></td>
</tr>
<tr>
<td>Алгоритма ''PAM''</td>
<td><math>O(Q * K)</math></td>
<td><math>O(\frac{Q * K}{N})</math></td>
<td><math>O(\frac{Q + K}{N})</math></td>
</tr>
</table>

'''Основные достоинства алгоритма ''PAM''''':
* Менее чувствителен к выбросам, чем алгоритм <math>k</math>-средних
* Достаточно прост с точки зрения реализации
* Устойчив, поскольку не накапливает ошибок в процессе своей работы
* Возможно распараллеливание

'''Основные недостатки алгоритма ''PAM''''':
* Необходимо задание требуемого числа кластеров
* Квадратичная вычислительная сложность

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

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

Для исследования масштабируемости алгоритма ''PAM'' использовалась доступная на github[https://github.com/al-pacino/Clustering] реализация алгоритма. Исследование проводилось на суперкомпьютере BlueGene/P[http://hpc.cmc.msu.ru/bgp].

Были измерено время выполнения для каждой из двух, составляющих всю программу, частей:
* Чтение и подготовка исходных данных
* Выполнение алгоритма ''PAM''

Для проведения измерений было подготовлено 6 наборов псевдослучайных данных, содержащих от 1024 до 6144 (с шагом 1024) объектов кластеризации. Измерения проводились для числа процессов равного 1 и кратного 4 в диапазоне от 1 до 256: 1, 4, 8, 16, ..., 252, 256.

На рисунке 2.4.1 показана зависимость времени чтения и подготовки исходных данных от числа процессов и размера данных. График наглядно демонстрирует, что данное время в исследуемой реализации зависит лишь от объёма данных, но не от числа процессов. Также можно заметить небольшие шероховатости на графике, свидетельствующие о том, что данное время может незначительно изменяться от запуска к запуску.
[[file:PAM_time_read.png|thumb|center|1024px|Рисунок 2.4.1. Время чтения (в секундах) и подготовки исходных данных]]

На рисунке 2.4.2 показана зависимость времени работы алгоритма ''PAM'' от числа процессов и размера данных. График иллюстрирует хорошую масштабируемость алгоритма в случае, когда число объектов кластеризации превышает число процессов.
[[file:PAM_time_pam.png|thumb|center|1024px|Рисунок 2.4.2. Время (в секундах) выполнения алгоритма ''PAM'']]

На рисунке 2.4.3 показана зависимость общего времени работы программы от числа процессов и размера данных. Заметно ухудшение масштабируемости по сравнению с графиком на рисунке 2.4.2.
[[file:PAM_time_whole.png|thumb|center|1024px|Рисунок 2.4.3. Общее время (в секундах) выполнения программы]]

На рисунке 2.4.4 показана зависимость эффективности алгоритма ''PAM'' от числа процессов и размера данных. График показывает, что эффективность снижается не очень быстро с ростом числа процессов, что также иллюстрирует хорошую масштабируемость алгоритма в случае, когда число объектов кластеризации превышает число процессов.
[[file:PAM_efficiency_pam.png|thumb|center|1024px|Рисунок 2.4.4. Эффективность (от 0 до 1) алгоритма ''PAM'']]

На рисунке 2.4.5 показана зависимость эффективности работы всей программы от числа процессов и размера данных. Заметно ухудшение по сравнению с графиком на рисунке 2.4.4, за счёт добавления времени чтения и подготовки исходных данных. Эффективность заметно падает, с ростом числа процессов: время чтения и подготовки исходных данных остаётся неизменным, а время работы алгоритма ''PAM'' не даёт ускорения поскольку оно значительно меньше, чем время чтения и подготовки исходных данных (начиная с определённого числа процессов).
[[file:PAM_efficiency_whole.png|thumb|center|1024px|Рисунок 2.4.5. Эффективность (от 0 до 1) всей программы]]

Масштабируемость рассматриваемой реализации алгоритма ''PAM'':

* При увеличении числа процессов общая эффективность программы уменьшается, т.к. время чтения и подготовки исходных данных остаётся неизменным и начинает преобладать над временем работы алгоритма ''PAM''.
* При увеличении числа объектов кластеризации общая эффективность программы постепенно увеличивается, т.к. время чтения и подготовки исходных данных растёт медленнее, чем время работы алгоритма ''PAM''.
* При одновременном увеличении как числа процессов, так и числа объектов кластеризации общая эффективность программы уменьшается.

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

# Последовательная реализация алгоритма PAM в пакете ClusterR на языке R:
#* Лицензия: MIT
#* [https://cran.r-project.org/package=ClusterR веб-страница фреймворка (исходный код, системные требования и справочное руководство)]
#* Алгоритм PAM реализован в функции 'Cluster_Medoids'. Отличительная особенность реализации <ref>Lampros Mouselimis [https://cran.r-project.org/web/packages/cluster/cluster.pdf Package 'ClusterR']. October 8, 2016</ref>:
#** для задания метрики между элементами кластеризуемого множества передаётся строка, задающая одну из реализованных в алгоритме метрик. Данный подход теряет одно из преимуществ алгоритма PAM, позволяющее в качестве матрицы расстояний использовать произвольную матрицу различий.
#:
#:
# Последовательная реализация алгоритма PAM в пакете Cluster на языке R:
#* Лицензия: GPL (≥2)
#* [https://cran.r-project.org/package=cluster веб-страница фреймворка (исходный код, системные требования и справочное руководство)]
#* Алгоритм PAM реализован в функции 'pam()'. Данная реализация имеет следующие особенности <ref>Martin Maechler., etc. [https://cran.r-project.org/web/packages/cluster/cluster.pdf Package 'cluster']. October 8, 2016</ref>:
#** функция может принимать на вход не множество точек, а матрицу расстояний между ними;
#** реализация более гибкая, так как принимает на вход матрицу различий элементов, а не использует какую-либо метрику;
#** может быть предоставлено графическое отображение.
#:
#:
#:
# Параллельная реализация алгоритма PAM в пакете SPRINT (Simple Parallel R INTerface - параллельный фреймворк) на языке R:
#* Лицензия: GPL (≥3)
#* [https://cran.r-project.org/package=sprint веб-страница фреймворка (исходный код, системные требования и справочное руководство)]
#* Алгоритм PAM реализован в фукции 'ppam()'. Входные параметры данной функции схожи с параметрами, задаваемыми в линейной реализации 'pam()' пакета Cluster языка R. Отличительной особенностью является подача на вход предвычисленной матрицы расстояний (например, с помощью функции 'pcor()' из этой же библиотеки).<ref>University of Edinburgh SPRINT Team. [https://cran.r-project.org/web/packages/sprint/sprint.pdf Package 'sprint']. February 20, 2015</ref>
#:
#:
# Параллельная реализация алгоритма PAM на основе операций MapReduce на Hadoop кластере.
#* В рамках исследования по ускорению анализа информации о геноме были созданы реализации алгоритма PAM с использованием технологии MPI и технологии MapReduce. Реализация в открытом досупе отсутствует. <ref>[Dobrzelecki B. et al. Managing and analysing Genomic Data using HPC and Clouds //Grid and Cloud Database Management. – Springer Berlin Heidelberg, 2011. – С. 261-277.</ref>

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

<references />

[[Категория:Начатые статьи]]

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

2016-11-18T14:34:44Z

Dexter: Новая страница: «1) п1.1 - что такое плоское разбиение? Поясните 2) п1.2 - рисунок малоинформативный. Что такое…»

1) п1.1 - что такое плоское разбиение? Поясните

2) п1.2 - рисунок малоинформативный. Что такое Border, Core и т.д.? Наверно, лучше сделать надписи по-русски, раз уж статья на русском

3) п1.4 - про деревья здесь лишнее, макроструктура - это описание алгоритма с "птичьего полета"

4) п1.5 вместо "ядровой объект" лучше "объект, являющийся ядром" ; вместо комментариев "// Вспомогательная функция" лучше сделать подписи к кускам кода

5) п1.7 - что такое PDBSCAN? На рис.2 с разбиением не очень понятно, что значат разноцветные
прямоугольники.

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

2016-11-18T14:30:43Z

Dexter: Новая страница: «1) п 2.1 и 2.4 не заполнены 2) п 1.3 - здесь больше сказано о метрике Минковского и евклидовой; с…»

1) п 2.1 и 2.4 не заполнены

2) п 1.3 - здесь больше сказано о метрике Минковского и евклидовой; сделайте более развернутым собственно описание вычислительного ядра алгоритма

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

2016-11-18T10:09:12Z

Dexter:

{{Assignment|Преподаватель 1|Dexter}}
{{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 />

Обсуждение участника:Антон Тодуа/Partitioning Around Medoids (PAM)

2016-11-16T19:53:16Z

Dexter:

* '''Замечания второго рецензента'''
* п1.4 - в формулах для T_{ijh} есть min, но непонятно, по какому индексу берется минимум
* как вычисляется d_{ij}, по какой метрике? Это нужно добавить

1) Нет верхней врезки со свойствами последовательной и параллельной версии алгоритма (см. страницу-образец)
 ИСПРАВЛЕНО

Обсуждение участника:Антон Тодуа/Partitioning Around Medoids (PAM)

2016-11-16T19:44:21Z

Dexter:

* '''Замечания второго рецензента'''
* п1.4 - в формулах для T_{ijh} есть min, но непонятно, по какому индексу берется минимум

1) Нет верхней врезки со свойствами последовательной и параллельной версии алгоритма (см. страницу-образец)
 ИСПРАВЛЕНО

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

2016-11-16T19:38:07Z

Dexter:

п. 1.4

* В описании евклидовой метрики d(a, b) достаточно короткой формы - со знаком "сигма"

п. 1.10

* Почему сказано о вычислительной мощности алгоритма к средних, а не алгоритма PAM?

п. 2.4

* нет описания аппаратной платформы
* нет указания на реализацию алгоритма (своя или сторонняя)
[[Участник:Zhum|Zhum]] ([[Обсуждение участника:Zhum|обсуждение]]) 10:16, 16 ноября 2016 (MSK)

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

2016-11-16T19:35:42Z

Dexter:

п. 1.4
В описании евклидовой метрики достаточно короткой формы - со знаком "сигма"

п. 2.4

* нет описания аппаратной платформы
* нет указания на реализацию алгоритма (своя или сторонняя)
[[Участник:Zhum|Zhum]] ([[Обсуждение участника:Zhum|обсуждение]]) 10:16, 16 ноября 2016 (MSK)

Обсуждение участника:Avasilenko/Partitioning Around Medoids (PAM)

2016-11-16T19:32:10Z

Dexter:

п1.4 - почему используется то minimum, то min? Зачем такая сложная расшифровка минимума value по всем элементам Y?

# Поясните, что значит "плоский алгоритм кластеризации" в п 1.1
#* ''добавлено определение плоской и иерархической кластеризации''
# Что значит "множественные вычисления" в п 1.3?
#* ''фраза "множественные вычисления" употреблялось в значении "многочисленные вычисления" (по аналогии с тем как это делалось в эталонной статье "Разложение Холецкого"), в нашей статье фраза была заменена''
# В п1.4 - нет определения функций minimum (или это просто min?) и value
#* ''minimum - это операция нахождения минимального среди нескольких значений, принимаемых некоторой функцией (наличие данной макрооперации обусловлено тем, что компьютер может одновременно вычислить лишь минимум 2-х чисел (посредством их сравнения)). Функция value при этом является любой (поэтому будет указываться при вызове minimum).''
# Псевдокод в 1.5 - много общих фраз, нужно написать детальнее
#* ''псевдокод был детализирован''

''Был оформлен параграф 2.3 "Возможные способы и особенности параллельной реализации алгоритма". Согласно заданию он не требуется, поэтому является дополнительной частью, которая была оформлена (так уж получилось).''

''Дописан параграф 2.4 "Масштабируемость алгоритма и его реализации". Реализация написана самостоятельно. Сетка сгенерирована достаточно подробно для обнаружения 'особых точек', как рекомендовал Владимир Валентинович.''

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

2016-11-16T19:23:09Z

Dexter:

п. 1.1
проверьте формулу для E. Суммирование идет по j, но в слагаемых индекс j отсутствует

п. 2.4

* не указано, какая реализация алгоритма использовалась - собственная или библиотечная
*: [[Участник:Zhum|Zhum]] ([[Обсуждение участника:Zhum|обсуждение]]) 11:28, 16 ноября 2016 (MSK)
** ''Ссылка на реализацию была указана в конце параграфа. Явно добавили указание, что реализация собственная.''

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

2016-11-16T18:34:56Z

Dexter:

1) п1.2.2 Что такое n с двойной индексацией?

2) Общие слова о модернизациях - плохой заголовок, переформулируйте

3) п1.5 очень плохое выравнивание в псевдокоде

4) Почему поэлементное умножение вектора на вектор обозначается так же как поэлементное деления вектора на вектор?

Участник:Мария Готман/Алгоритм кластеризации, основанный на максимизации ожидания

2016-11-16T18:32:40Z

Dexter:

{{Assignment|Преподаватель 1|Dexter}}
Авторы описания: [[Участник:Мария_Готман|Готман М.Л.]], [[Участник: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</math>, то есть 3 входных объекта.

На рис.1 показана макроструктура EM-алгоритма. Входными данными в таком случае являются матрица <math>X \in \R^{3 \times d}</math>, число кластеров <math>= K</math>, число признаков <math>=d</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 d}</math> являются строчками входной матрицы <math>X</math>, также на вход подаются текущие приближения векторов средних значений (<math>\mu_1, \dots, \;\mu_K</math>), матриц ковариаций (<math>\Sigma_1, \dots, \Sigma_K</math>) и весов <math>w</math>.

Вершинами <math>\mathbf{eI}</math> обозначена операция нахождения обратной матрицы <math>\Sigma_j^{-1},\; j = 1,\dots,K</math>. Вершины группы <math>\mathbf{eS}</math> обозначают вычитание векторов <math>x_i - \mu_j,\; i = 1,2,3; \; j = 1,\dots,K</math>. Салатовые узлы графа <math>\mathbf{eE}</math> обозначают вычисление ненормированного значения <math>g_{ij}, \;i = 1,2,3;\;j=1,\dots,K</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 d}</math>, скрытые переменные <math>g_{11},\;g_{21},\;g_{31},\;\mu_1</math> для пересчета параметров первого кластера и <math>g_{1K},\;g_{2K},\;g_{3K},\;\mu_K</math> — для K-ого кластера.

Вершина <math>\mathbf{m}\boldsymbol{\mu}</math> обозначает подсчет слагаемого математического ожидания для одного объекта, затем на шаге <math>\mathbf{mS_1}</math> происходит суммирование слагаемых, и, наконец, на шаге <math>\mathbf{mN_1}</math> нормировка математического ожидания, выходом являются <math>\mu_1,\dots,\;\mu_K</math>.
Вершина <math>\mathbf{m}\boldsymbol{\Sigma}</math> обозначает подсчет слагаемого матрицы ковариации для одного объекта, затем на шаге <math>\mathbf{mS_2}</math> происходит суммирование слагаемых, и, наконец, на шаге <math>\mathbf{mN_2}</math> нормировка матрицы ковариации, выходом являются <math>\Sigma_1,\;\dots,\;\Sigma_K</math>.
Операция <math>\mathbf{mS_3}</math> обозначает вычисление ненормированного веса для одного шага, затем при выполнении <math>\mathbf{mN_3}</math> происходит нормировка весов, выходом являются <math>w_1,\dots,\;w_K</math>.

[[file:EM M step2.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ти потоков.

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

[[file:EM-ef-time.png|thumb|center|700px|Рис. 4 Время работы EM алгоритма в зависимости от числа процессов и размера задачи]]

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

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

[[file:EM_Efficiency.png|thumb|center|700px|Рис. 5 Эффективность 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-16T18:32:16Z

Dexter:

{{Assignment|Преподаватель 1|Dexter}}
Авторы описания: [[Участник:Мария_Готман|Готман М.Л.]], [[Участник:Julia_lukashkina|Лукашкина Ю.Н.]]

{{Assignment}}
= ЧАСТЬ. Свойства и структура алгоритмов =
== Общее описание алгоритма ==
Задача кластеризации — это задача разбиения заданной входной выборки объектов на непересекающиеся подмножества, называемые кластерами, так, чтобы каждый кластер состоял из схожих объектов, а объекты разных кластеров существенно отличались.

Для решения этой задачи можно использовать, например, метод максимизации ожидания, также известный как 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</math>, то есть 3 входных объекта.

На рис.1 показана макроструктура EM-алгоритма. Входными данными в таком случае являются матрица <math>X \in \R^{3 \times d}</math>, число кластеров <math>= K</math>, число признаков <math>=d</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 d}</math> являются строчками входной матрицы <math>X</math>, также на вход подаются текущие приближения векторов средних значений (<math>\mu_1, \dots, \;\mu_K</math>), матриц ковариаций (<math>\Sigma_1, \dots, \Sigma_K</math>) и весов <math>w</math>.

Вершинами <math>\mathbf{eI}</math> обозначена операция нахождения обратной матрицы <math>\Sigma_j^{-1},\; j = 1,\dots,K</math>. Вершины группы <math>\mathbf{eS}</math> обозначают вычитание векторов <math>x_i - \mu_j,\; i = 1,2,3; \; j = 1,\dots,K</math>. Салатовые узлы графа <math>\mathbf{eE}</math> обозначают вычисление ненормированного значения <math>g_{ij}, \;i = 1,2,3;\;j=1,\dots,K</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 d}</math>, скрытые переменные <math>g_{11},\;g_{21},\;g_{31},\;\mu_1</math> для пересчета параметров первого кластера и <math>g_{1K},\;g_{2K},\;g_{3K},\;\mu_K</math> — для K-ого кластера.

Вершина <math>\mathbf{m}\boldsymbol{\mu}</math> обозначает подсчет слагаемого математического ожидания для одного объекта, затем на шаге <math>\mathbf{mS_1}</math> происходит суммирование слагаемых, и, наконец, на шаге <math>\mathbf{mN_1}</math> нормировка математического ожидания, выходом являются <math>\mu_1,\dots,\;\mu_K</math>.
Вершина <math>\mathbf{m}\boldsymbol{\Sigma}</math> обозначает подсчет слагаемого матрицы ковариации для одного объекта, затем на шаге <math>\mathbf{mS_2}</math> происходит суммирование слагаемых, и, наконец, на шаге <math>\mathbf{mN_2}</math> нормировка матрицы ковариации, выходом являются <math>\Sigma_1,\;\dots,\;\Sigma_K</math>.
Операция <math>\mathbf{mS_3}</math> обозначает вычисление ненормированного веса для одного шага, затем при выполнении <math>\mathbf{mN_3}</math> происходит нормировка весов, выходом являются <math>w_1,\dots,\;w_K</math>.

[[file:EM M step2.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ти потоков.

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

[[file:EM-ef-time.png|thumb|center|700px|Рис. 4 Время работы EM алгоритма в зависимости от числа процессов и размера задачи]]

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

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

[[file:EM_Efficiency.png|thumb|center|700px|Рис. 5 Эффективность 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 \>

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

2016-11-16T18:31:07Z

Dexter:

{{Assignment|Преподаватель 1|Dexter}}
{{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 \>

Участник:Александр Куваев/Алгоритм кластеризации, основанный на максимизации ожидания

2016-11-16T18:30:16Z

Dexter:

{{Assignment|Преподаватель 1|Dexter}}
{{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 также эффективно распараллеливается по объектам с последующей агрегацией результатов по кластерам: параллельная сложность M-шага — <math>O(k * n)</math>.

Таким образом, параллельная сложность EM-алгоритма — <math>O(imax * k * n^{2})</math>.

=== Входные и выходные данные алгоритма ===
'''Входные данные:''' плотная матрица объектов-признаков <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-алгоритма:
* В классическом варианте не может самостоятельно определить количество компонент смеси
* Трудоемкий и неустойчивый процесс обращения матриц ковариаций в случае несферических компонент смеси
* Не является детерминированным: в начале работы происходит инициализация начальных параметров случайным образом
* Не является устойчивым: результат работы сильно зависит от инициализации параметров. При неудачной инициализации может обладать низкой скоростью сходимости, может сойтись к локальному экстремуму или не сойтись вовсе

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

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

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

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

=== Масштабируемость алгоритма и его реализации ===
Исследование масштабируемости параллельной реализации EM-алгоритма проводилось на суперкомпьютере Blue Gene/P. Для этого использовалась собственная реализация алгоритма, написанная на языке C++ с использованием технологий MPI и OpenMP.

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

Набор значений параметров запуска реализации алгоритма:
* число процессоров: 1, 8, 16, 32, 48, 64, 80, 96, 112, 128
* число элементов выборки: 1000, 25000, 50000, 75000, 100000, 200000, 300000, 400000, 500000, 600000, 700000, 800000, 900000, 1000000
* размерность пространства признаков: 2
* число кластеров: 2
* максимальное число итераций: MAX_INT
* минимальная величина изменения логарифма правдоподобия: 1e-6

Начальные значения параметров смеси задавались следующим образом:
* центры кластеров - случайные элементы выборки
* матрицы ковариаций - единичные
* веса компонент равны между собой

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

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

[[File:EM_time.png|thumb|center|1200px|Рисунок 4. Зависимость времени работы параллельной реализации EM-алгоритма от числа процессоров и числа элементов выборки.]]

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

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

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

=== Существующие реализации алгоритма ===
# [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]

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

Обсуждение участника:Elmon/Плотностный алгоритм кластеризации DBSCAN

2016-11-14T15:49:29Z

Dexter: Новая страница: «1) Проверьте орфографию и грамматику - встречаются фразы типа "Выбирается произвольная н…»

1) Проверьте орфографию и грамматику - встречаются фразы типа "Выбирается произвольная непосещенный"

2) Явно не сказано, что такое n

Обсуждение участника:Elena777mc/Плотностный алгоритм кластеризации DBSCAN

2016-11-14T15:23:15Z

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

2016-11-14T15:04:42Z

Dexter: Новая страница: «1) п1.2.2 Что такое n с двойной индексацией? 2) Общие слова о модернизациях - плохой заголовок…»

Обсуждение участника:Мария Готман

2016-11-12T10:00:32Z

Dexter:

== Замечания второго рецензента ==
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)? созданы ли они авторами для этой статьи, публиковались ли где-то ещё?

Все рисунки создавались авторами статьи, исходники есть, больше нигде не публиковались.

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

2016-11-12T09:25:52Z

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

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

1) лишняя строка "Алгоритм кластеризации, основанный на максимизации ожидания (EM-алгоритм)" перед содержанием --- убрано

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

3)'''Ниже - замечания второго рецензента'''

4) Во врезке так и не появилась информация по поводу параллельного алгоритма

5)Из содержания нужно убрать ссылку [5]

6) В формулировке задачи в п1.1 нет разъяснения параметра m

7) В п1.2 парметры m, n, k почему-то превратились в M, N, K

8) П 1.5. Как инициализируются скрытые переменные gamma? Выравнивание псевдокода местами нарушено. Слово "большУю" - здесь лучше использовать значок ударения

9) П 1.7 Информационный граф: на рисунке омега превратилась в w, гамма - в Y.

10)П 1.9 Выходные данные - сказано о векторе n. Поясните, какое значение он имеет в терминах алгоритма кластеризации.

Обсуждение участника:Maria Zaitseva/PAM (Partitioning Around Medoids)

2016-11-07T20:20:35Z

Dexter:

1) В верхней врезке нет свойств параллельной версии алгоритма (см страницу-образец)

2) Называть множества маленькими буквами - плохая идея

3) На рис.2 показана ситуация для шага t, но буква t не участвует в подписях на рисунке

Обсуждение участника:Антон Тодуа/Partitioning Around Medoids (PAM)

2016-11-05T18:48:44Z

Dexter: Новая страница: «1) Нет верхней врезки со свойствами последовательной и параллельной версии алгоритма (см…»

1) Нет верхней врезки со свойствами последовательной и параллельной версии алгоритма (см. страницу-образец)

Обсуждение участника:Maria Zaitseva/PAM (Partitioning Around Medoids)

2016-11-05T18:47:44Z

Dexter: Новая страница: «1) В верхней врезке нет свойств параллельной версии алгоритма (см страницу-образец)»

1) В верхней врезке нет свойств параллельной версии алгоритма (см страницу-образец)

Обсуждение участника:Avasilenko/Partitioning Around Medoids (PAM)

2016-11-05T18:31:14Z

Dexter:

1) Поясните, что значит "плоский алгоритм кластеризации" в п 1.1

2) Что значит "множественные вычисления " в п 1.3?

3) В п1.4 - нет определения функций minimum (или это просто min?) и value

4) Псевдокод в 1.5 - много общих фраз, нужно написать детальнее

Обсуждение участника:Avasilenko/Partitioning Around Medoids (PAM)

2016-11-05T18:24:27Z

Dexter:

1) Поясните, что значит "плоский алгоритм кластеризации" в п 1.1

2) Что значит "множественные вычисления " в п 1.3?