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

Участник:Sarseev/Алгоритм кластеризации, основанный на минимальном покрывающем дереве

2016-12-07T14:18:02Z

Zhum:

{{Assignment|Zhum}}

'''Автор''': Арсеев С. П., группа 620

== Свойства и структура алгоритма ==
=== Общее описание алгоритма ===
Данный алгоритм нацелен на решение задачи кластеризации, то есть, разделения множества объектов на группы, называемые кластерами, так, чтобы внутри одного кластера оказались наиболее похожие (по некоторой метрике) друг на друга объекты, а объекты из разных кластеров как можно сильнее отличались друг от друга.
Сам алгоритм состоит из следующих шагов:
# Сведение набора объектов к графу. Объекты становятся вершинами графа, и каждые две вершины соединяются ребром, длина которого равняется расстоянию между этими объектами по некоторой метрике. Выбор метрики зависит от предметной области и желаемых свойств алгоритма. Например, метрикой может служить евклидово расстояние.
# Построение минимального покрывающего (остовного) дерева в этом графе. Более подробно этот шаг описан в [[Построение_минимального_остовного_дерева_(MST)|соответствующей статье]].
# Кластеризация путём удаления некоторого количества рёбер в этом дереве. В случае, если заранее известно количество кластеров <math>k</math>, достаточно удалить <math>k-1</math> ребро с наибольшей длиной, чтобы получить <math>k</math> связных компонент, которые объявляются кластерами. Если же количество кластеров заранее не известно, удаляются рёбра с длиной больше некоторого порога, задаваемого как параметр алгоритма. Возможны и более сложные стратегии выбора рёбер для отсечения.
=== Математическое описание алгоритма ===
На вход алгоритму подаётся <math>n</math> объектов <math>a</math>, которые нужно кластеризовать. Каждый такой объект можно рассматривать как вектор или элемент некоторого метрического пространства. На пространстве, которому принадлежат <math>a</math>, задана метрика <math>d_{ij}=d(a_i,a_j)</math>. 
Первый шаг алгоритма строит граф <math>G=(V,E)</math>, где <math>V</math> - множество вершин графа <math>(|V|=n)</math>, а <math>E</math> - множество его рёбер <math>(|E| = \frac{n*(n-1)}{2})</math>. 
На втором этапе строится минимальное покрывающее дерево <math>MST(G)</math>. После удаления рёбер дерево распадается на поддеревья <math>MST_i</math>. Вершины, входящие в <math>i</math>-е поддерево, объявляются принадлежащими кластеру с номером <math>i</math>.
=== Вычислительное ядро алгоритма ===
Алгоритм состоит из трёх этапов:
# Преобразование исходных данных. Сложность <math>O(n^2)</math>.
# Поиск минимального покрывающего дерева. Последовательная сложность всех трёх основных алгоритмов ([[Алгоритм_Борувки|Борувки]], [[Алгоритм_Крускала|Крускала]] и [[Алгоритм_Прима|Прима]]) <math>O(|E|*log(|E|)) = O(n^2*log(n^2))</math>.
# Разбиение на кластеры. Вычислительная сложность <math>O(n)</math> для простых стратегий разбиения.
Таким образом, вычислительным ядром алгоритма является алгоритм построения минимального покрывающего дерева, поскольку он имеет наибольшую сложность. Стратегии распараллеливания алгоритма основаны на распараллеливании алгоритма построения минимального покрывающего дерева.
=== Макроструктура алгоритма ===
В состав алгоритма входит алгоритм [[Построение_минимального_остовного_дерева_(MST)|построения минимального покрывающего дерева]], являющийся его вычислительным ядром. Также в отдельную часть можно выделить алгоритм разбиения получившегося покрывающего дерева на кластеры.
=== Схема реализации последовательного алгоритма ===
Описание алгоритма на псевдокоде:
<source lang=cpp>
MST_Cluster(object[n] objects){
g = Pairs(objects, metric);
mst = Create_MST(graph);
parts = Split_MST(mst);
for i in range(parts){
clusters[i] = parts[i].vertices;
}
return clusters
}

</source>
=== Последовательная сложность алгоритма ===
Последовательная сложность алгоритма определяется самой сложной его частью (см. пункт 1.3) и равна <math>O(n^2*log(n^2))</math>.
=== Информационный граф ===
[[Файл:MST_cluster.png|thumb|center|1043px|Информационный граф алгоритма. Показана последовательная реализация (большой прямоугольник) и схема распараллеливания алгоритма построения минимального покрывающего дерева.]]
=== Ресурс параллелизма алгоритма ===
Ресурс параллелизма алгоритма основан на свойстве ассоциативности рёбер: 
Пусть <math>MSF(E)</math> – минимальный остовный лес (множество покрывающих деревьев) графа с рёбрами <math>E</math>. Тогда
:<math>
MSF(E_1 \cup E_2 \cup \dots \cup E_k) = MSF(MSF(E_1) \cup MSF(E_2) \cup \dots \cup MSF(E_k)).
</math>

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

Сложность параллельного алгоритма зависит от соотношения объёма входных данных и числа процессов. Существуют распределённые алгоритмы построения минимального покрывающего дерева, имеющие асимптотическую сложность <math>O(n*log(n))</math>. Эта же оценка будет выполняться и для всего алгоритма кластеризации.

=== Входные и выходные данные алгоритма ===
На вход алгоритму подаются объекты <math>(o_1, o_2, ..., o_n)</math>. 
Выходом алгоритма является множество непересекающихся кластеров: <math>C=(C_1, C_2, ..., C_k); C_i = (o_{i,1}, o_{i,2}, ..., o_{i, n_i}); o(i, l) \ne o(j, m); i \ne j; \forall l, m; \sum{n_i} = n </math>.
=== Свойства алгоритма ===
Важным свойством алгоритма является то, что при его распараллеливании по описанной выше стратегии важно правильно выбирать количество процессов. При увеличении количества процессов возрастают затраты на фазу слияния деревьев, полученных каждым процессом: растёт число этапов, в которые производится слияние, а следовательно, возрастают затраты на коммуникацию между процессами, и распределение нагрузки становится более неравномерным из-за того, что часть процессов должна проделать значительно большее количество работы по слиянию деревьев. 
Вычислительная мощность алгоритма имеет порядок <math>O(n*log(n^2))</math>. 
Ещё одним важным свойством алгоритма является его детерминированность в том случае, если для данного набора векторов существует единственное минимальное покрывающее дерево: при использовании детерминированной стратегии разбиения его на поддеревья алгоритм получает единственный результат для каждого набора данных. Однако, время работы может отличаться в зависимости от начального распределения рёбер по процессам.
== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===
[[Файл:MST_cluster_time.png|thumb|center|600px|Время работы алгоритма в зависимости от числа процессов и объёма входных данных.]] 
[[Файл:Mst_scale2.PNG|thumb|center|600px|Время работы алгоритма при меньшем числе процессов и объёме входных данных.]] 
[[Файл:Mst_cluster_efficiency.PNG|thumb|center|600px|Эффективность распараллеливания алгоритма.]] 
На первом и втором графике на логарифмической шкале показана зависимость времени работы алгоритма от числа процессов. Приведены измерения для девфти наборов данных, различающихся количеством входных векторов: от 512 до 131072 элементов. Использовалась собственная реализация алгоритма, основанная на [https://github.com/gpiskas/MinSpanTree_Kruskal_MPI_OpenMP сторонней реализации] алгоритма построения минимального покрывающего дерева (без OpenMP-части для более точного измерения масштабируемости описанной выше архитектуры). Изменения относительно приведённой реализации в основном коснулись генерации входных данных для алгоритма построения остовного дерева: в качестве функции расстояния между элементами при генерации графа бралось случайное число от 0 до 1. Изменения времени работы алгоритма при разных запусках (и, соответственно, с другим набором случайных чисел) незначительны. 
Полный текст изменённой части программы расположен по адресу [http://pastebin.com/5US84UgR]. 
Запуск проводился на аппаратной платформе [http://hpc.cmc.msu.ru/bgp IBM BlueGene/P]. Для каждого размера входных данных были проведены четыре теста: на 128, 256, 512 и 1024 вычислительных узлах соответственно. При дальнейшем увеличении объёма данных время выполнения программы превысило доступный предел (15 минут для 128 узлов). 
Из первого и второго графиков видно, что время работы алгоритма возрастает с увеличением объёма входных данных с зависимостью, близкой к квадратической, что соответствует теоретической оценке сложности алгоритма (<math>O(n^2*log(n^2))</math>). Вычислительная сложность последовательной части алгоритма (кластеризация уже построенного остовного дерева) мала по сравнению со сложностью его параллельной части, что приводит к существенному снижению времени работы алгоритма при увеличении количества вычислительных узлов. 
На третьем графике показана зависимость эффективности распараллеливания алгоритма в зависимости от числа вычислительных уздов и объёма входных данных. Видно, что эффективность быстро падает для малого объёма входных данных (из-за возрастающих затрат на обмен информацией) и остаётся высокой на графе из 2048 вершин. При большом объёме входных данных и большом числе вычислительных узлов эффективность распараллеливания начинает снижаться. Это вызвано возрастанием затрат на фазу слияния, приводящим к неравномерной загрузке процессора. График эффективности распараллеливания для объёмов данных, показанных на графике 1, построить невозможно из-за аппаратных ограничений (при выполнении алгоритма на одном процессоре рёбра графа не поместятся в память вычислительного узла, а время выполнения окажется слишком большим), но тенденция снижения эффективности распараллеливания видна на третьем графике. 

=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===
Основным вычислительным ядром алгоритма является алгоритм построения минимального покрывающего (остовного) дерева, применяющийся для многих задач, и многие библиотеки ограничиваются его реализацией, без реализации основанного на нём алгоритма кластеризации. Примеры реализаций алгоритмов построения MST:
* С++: [http://www.boost.org/doc/libs/1_62_0/libs/graph/doc/ Boost graph library] (алгоритмы Борувки и Крускала)
* C++, MPI: [http://www.boost.org/doc/libs/1_62_0/libs/graph_parallel/doc/html/index.html Parallel boost graph library] (алгоритм Борувки)
* Java: [http://jgrapht.org/ JGraphT] (алгоритмы Крускала и Прима)
* Python: [http://docs.scipy.org/doc/scipy-0.15.1/reference/index.html SciPy]
== Литература ==
# Нейский И.М. Классификация и сравнение методов кластеризации 
# C. Kingsford. Minimum Spanning Trees & Clustering ([https://www.cs.umd.edu/class/fall2009/cmsc451/lectures/Lec07a-mst.pdf])
# Y. Zhou et al. Clustering with Minimum Spanning Trees

Участник:Tereshinvs/MST Clusterization

2016-12-06T12:29:50Z

Zhum:

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

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

Постановка задачи также может различаться характером входных данных:
# Набор признаков <math> V = \left\{ v_1, v_2, \ldots, v_N \right\} </math> в некотором метрическом пространстве с метрикой <math> \rho(x, y) </math>
# Матрица отношений между объектами: симметричная матрица вещественных чисел размером <math> N \times N </math> с неотрицательными элементами с нулевой диагональю.

В данной статье рассматривается постановка с известным количеством кластеров <math> K </math>.

В данной статье рассматривается алгоритм алгоритм кластеризации на основе MST (Minimum spanning tree — минимальное остовное дерево).

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

Общая схема алгоритма:
# Построение минимального остовного дерева одним из известных методов (алгоритмы Крускала, Прима, Борувки и их комбинации; наиболее пригодным для параллельного исполнения считается алгоритм Борувки)
# Удаление <math> K-1 </math> самых длинных рёбер из минимального остовного дерева.

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

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

=== Математическое описание алгоритма ===
Пусть <math>V</math> — множество объектов, <math>Y</math> — множество номеров (имён, меток) кластеров. Задана функция расстояния между объектами <math>\rho(x,y)</math>. Требуется разбить выборку на непересекающиеся подмножества, называемые ''кластерами'', так, чтобы каждый кластер состоял из объектов, близких по метрике <math>\rho</math>, а объекты разных кластеров существенно отличались. При этом каждому объекту <math>v_i\in V</math>
приписывается номер кластера <math>y_i</math>.

''Алгоритм кластеризации'' — это функция <math>a\colon V\to Y</math>, которая любому объекту <math>v\in V</math> ставит в соответствие номер кластера <math>y\in Y</math>. Множество <math>Y</math> в некоторых случаях известно заранее, однако чаще ставится задача определить оптимальное число кластеров, с точки зрения того или иного ''критерия качества'' кластеризации.

В данном случае задачу можно сформулировать так: выбрать пороговое значение веса ребра <math>W</math>, так чтобы объекты, соединённые ребром весом меньше <math>W</math> лежали в одном кластере, а соединённые ребром весом больше <math>W</math> — в разных.

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

=== Макроструктура алгоритма ===
Основной алгоритм можно разделить на следующие части:
# Нахождение для каждой вершины наименьшего ребра, инциндентного ней
# Добавление найденных наименьших вершин в MST
# "Склейка" компонент связности MST
# Нахождение веса <math>W_{K-1}</math> <math>(K-1)</math>-ого наибольшего ребра
# Удаление рёбер весом не меньше чем <math>W_{K-1}</math>.
=== Схема реализации последовательного алгоритма ===
<source lang="text" line start="0" highlight="1,9">
Ввод: граф V

Поместить каждую вершину в отдельное дерево леса T
Пока в T больше одной компоненты связности:
Для каждой компоненты C из T:
S — пустое множество рёбер
Для каждой вершины v в C:
Найти кратчайшее ребро с одним концом v, а другим не из C, и поместить его в S
Добавить кратчайшее ребро из S в T
Объединить компоненты связности
T — MST

Найти W — вес (K-1)-ого максимального ребра в T
Удалить из T рёбра с весом большим или равным W

Пронумеровать компоненты связности

Вывод: номера компонент связности для каждой вершины
</source>

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

# Нахождение ребер наименьшего веса для всех компонент связности требует <math>O(V)</math> операций на каждом шаге, где <math>V</math> — число рёбер в графе.
# Добавление новых рёбер в MST требует <math>O(N)</math> операций за всё время работы алгоритма.
# При использовании структуры данных система непересекающихся множеств с ранговой эвристикой, объединение деревьев требует примерно , где <math>O(N)</math> операций.
# Доказано, что количество шагов алгоритма <math>O(\log N)</math>.

Итого <math>O(V \log N)</math> операций. При использовании триангуляции Делонэ в некоторых случаях <math>V</math> имеет тот же порядок, что и <math>N</math>, поэтому общая сложность <math>O(N \log N)</math>. В общем же случае сложность составляет <math>O(N^2 \log N)</math>

Удаление <math>K-1</math> рёбер можно осуществить за <math>O(N)</math> операций.

Итак, общая сложность алгоритма в общем случае <math>O(N^2 \log N)</math>.

=== Информационный граф ===
[[File:Tereshinvs_mst_scheme.png|frame|center|alt=Информационный граф|Информационный граф алгоритма кластеризации на основе минимального остовного дерева]]

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

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

Узким местом является нахождение k-ой порядковой статистики для выделения кластеров, а так же объединение компонент связности. Но всего объединений компонент связности <math>N-1</math>, поэтому при его реализации с помощью структуры данных система непересекабщихся множеств с ранговой эвристикой общая сложность за всё время работы алгоритма будет близко к <math>O(N)</math>.
=== Входные и выходные данные алгоритма ===
Входными данными являются число <math> N </math> (количество элементов рассматриваемого множества) и матрица вещественных чисел размера <math> N \times N </math> отношений между элементами этого множества. Матрица предполагается симметричной, а её диагональные элементы равными нулю, поэтому её размер можно оценить как <math> \tfrac{N(N-1)}{2} </math>.

Кроме того, имеется натуральное число <math> K \leqslant N </math> — требуемое количество кластеров.

Выходными данными являются <math> N </math> натуральных чисел от <math> 1 </math> до <math> K </math> — номера кластеров, в которые определена каждая вершина. При этом, каждый кластер содержит хотя бы одну вершину.
=== Свойства алгоритма ===
Отрицательной сторой алгоритмов кластеризации, основанных на минимальных остовных деревьях, является их чувствительность к выбросам. С другой стороны, эти алгоритмы способны выделять кластеры произвольной формы, а результат их применения интуитивно понятен.

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

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

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

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

Интересной особенностью использования библиотеки Boost::graph::distributed является возможность задания изначального распределения вершин графа по процессам. К сложностям использования можно отнести нечитаемые сообщения об ошибках инстанцирования шаблонов С++ и отсутствие большого числа примеров использования библиотеки в интернете.

=== Масштабируемость алгоритма и его реализации ===
В этом параграфе описывается масштабируемость параллельной реализации алгоритма из библиотеки Boost::graph::distributed.

С использованием библиотеки Boost::graph::distributed программу можно реализовать следующим образом (указана только часть построения MST):

<source lang="C++" line start="0" highlight="1,9">
#include <boost/graph/use_mpi.hpp>
#include <boost/graph/distributed/mpi_process_group.hpp>
#include <boost/graph/distributed/adjacency_list.hpp>
#include <boost/graph/distributed/dehne_gotz_min_spanning_tree.hpp>
#include <boost/graph/distributed/vertex_list_adaptor.hpp>
#include <boost/graph/metis.hpp>

#include <iostream>
#include <fstream>
#include <vector>

typedef boost::adjacency_list<
boost::listS,
boost::distributedS<
boost::graph::distributed::mpi_process_group,
boost::vecS
>,
boost::undirectedS,
boost::no_property,
boost::property<
boost::edge_weight_t,
float
>
> Graph;

typedef boost::graph_traits<Graph>::edge_descriptor Edge;

int main(int argc, char* argv[])
{
boost::mpi::environment env(argc, argv);

std::ifstream in("big.graph");
boost::graph::metis_reader reader(in);

Graph graph(
reader.begin(), reader.end(),
reader.weight_begin(),
reader.num_vertices()
);

typedef boost::property_map<Graph, boost::edge_weight_t>::type WeightMap;
WeightMap weight_map = boost::get(boost::edge_weight, graph);

std::vector<Edge> mst_edges;

boost::graph::distributed::dense_boruvka_minimum_spanning_tree(
boost::graph::make_vertex_list_adaptor(graph),
weight_map,
std::back_inserter(mst_edges)
);

if (process_id(graph.process_group()) == 0)
std::cout << "Finished" << std::endl;
}
</source>

К сожалению, не удалось запустить программу, использующую данную библиотеку на суперкомпьютере IBM BlueGene/P, поэтому замеры производительности производились на компьютере с процессором Intel Core i5 4210U (два ядра и четыре потока, тактовая частота 1.7ГГц, до 2.7ГГц в режиме Turbo Boost), 6GB оперативной памяти DDR3, жёстким диском с частотой вращения шпинделя 5400 об/мин под управлением Windows 10 64-bit с использованием Windows Subsystem for Linux.

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

Замеры производились только для построения минимального остовного дерева для полного графа (вершины — объекты, рёбра с весами — отношения), так как это является вычислительным ядром алгоритма.

[[File:boost_mst_time.png|frame|center|alt=Время работы|Время работы алгоритма построения MST на полном графе из 5000 вершин, синем показана полученное время работы в секундах, зелёным — ожидаемое относительно увеличения количества процессором]]

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

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

=== Существующие реализации алгоритма ===
Библиотека шаблонов для С++ Boost предлагает прямую параллельную реализацию алгоритма Борувки в компоненте graph/distributed. Кроме этого, в ней имеются реализации других алгоритмов построения MST, а также много других параллельных алгоритмов на графах. Библиотека основана на технологии MPI. IBM предоставил патч для Boost 1.47.0 для её использования с компиляторами IBM CL C/C++.

Кроме этой библиотеки не существует распространённой библиотеки, реализующей параллельный алгоритм построения минимального остовного дерева. Но имеется достаточно большое количество библиотек, реализующих однопоточное построение MST:
* JGraphT для Java
* SciPy MST
* множество любительских реализаций, который можно легко найти в интернете по запросу "mst algorithm".

== Литература ==
# Нейский И.М. Классификация и сравнение методов кластеризации, http://it-claim.ru/Persons/Neyskiy/Article2_Neiskiy.pdf
# Minimum spanning tree, https://en.wikipedia.org/wiki/Minimum_spanning_tree
# Алгоритм Борувки, https://en.wikipedia.org/wiki/Bor%C5%AFvka%27s_algorithm
# Euclidean minimum spanning tree, https://en.wikipedia.org/wiki/Euclidean_minimum_spanning_tree
# Система непересекающихся множеств, http://e-maxx.ru/algo/dsu
# Boost Library, http://www.boost.org/
# Параллельное построение MST в библиотеке Boost, http://www.boost.org/doc/libs/1_55_0/libs/graph_parallel/doc/html/dehne_gotz_min_spanning_tree.html#id14
# Патч Boost 1.47.0 для IBM CL C/C++, http://www-01.ibm.com/support/docview.wss?uid=swg27027469

Участник:Sarseev/Алгоритм кластеризации, основанный на минимальном покрывающем дереве

2016-12-06T12:29:09Z

Zhum:

'''Автор''': Арсеев С. П., группа 620

== Свойства и структура алгоритма ==
=== Общее описание алгоритма ===
Данный алгоритм нацелен на решение задачи кластеризации, то есть, разделения множества объектов на группы, называемые кластерами, так, чтобы внутри одного кластера оказались наиболее похожие (по некоторой метрике) друг на друга объекты, а объекты из разных кластеров как можно сильнее отличались друг от друга.
Сам алгоритм состоит из следующих шагов:
# Сведение набора объектов к графу. Объекты становятся вершинами графа, и каждые две вершины соединяются ребром, длина которого равняется расстоянию между этими объектами по некоторой метрике. Выбор метрики зависит от предметной области и желаемых свойств алгоритма. Например, метрикой может служить евклидово расстояние.
# Построение минимального покрывающего (остовного) дерева в этом графе. Более подробно этот шаг описан в [[Построение_минимального_остовного_дерева_(MST)|соответствующей статье]].
# Кластеризация путём удаления некоторого количества рёбер в этом дереве. В случае, если заранее известно количество кластеров <math>k</math>, достаточно удалить <math>k-1</math> ребро с наибольшей длиной, чтобы получить <math>k</math> связных компонент, которые объявляются кластерами. Если же количество кластеров заранее не известно, удаляются рёбра с длиной больше некоторого порога, задаваемого как параметр алгоритма. Возможны и более сложные стратегии выбора рёбер для отсечения.
=== Математическое описание алгоритма ===
На вход алгоритму подаётся <math>n</math> объектов <math>a</math>, которые нужно кластеризовать. Каждый такой объект можно рассматривать как вектор или элемент некоторого метрического пространства. На пространстве, которому принадлежат <math>a</math>, задана метрика <math>d_{ij}=d(a_i,a_j)</math>. 
Первый шаг алгоритма строит граф <math>G=(V,E)</math>, где <math>V</math> - множество вершин графа <math>(|V|=n)</math>, а <math>E</math> - множество его рёбер <math>(|E| = \frac{n*(n-1)}{2})</math>. 
На втором этапе строится минимальное покрывающее дерево <math>MST(G)</math>. После удаления рёбер дерево распадается на поддеревья <math>MST_i</math>. Вершины, входящие в <math>i</math>-е поддерево, объявляются принадлежащими кластеру с номером <math>i</math>.
=== Вычислительное ядро алгоритма ===
Алгоритм состоит из трёх этапов:
# Преобразование исходных данных. Сложность <math>O(n^2)</math>.
# Поиск минимального покрывающего дерева. Последовательная сложность всех трёх основных алгоритмов ([[Алгоритм_Борувки|Борувки]], [[Алгоритм_Крускала|Крускала]] и [[Алгоритм_Прима|Прима]]) <math>O(|E|*log(|E|)) = O(n^2*log(n^2))</math>.
# Разбиение на кластеры. Вычислительная сложность <math>O(n)</math> для простых стратегий разбиения.
Таким образом, вычислительным ядром алгоритма является алгоритм построения минимального покрывающего дерева, поскольку он имеет наибольшую сложность. Стратегии распараллеливания алгоритма основаны на распараллеливании алгоритма построения минимального покрывающего дерева.
=== Макроструктура алгоритма ===
В состав алгоритма входит алгоритм [[Построение_минимального_остовного_дерева_(MST)|построения минимального покрывающего дерева]], являющийся его вычислительным ядром. Также в отдельную часть можно выделить алгоритм разбиения получившегося покрывающего дерева на кластеры.
=== Схема реализации последовательного алгоритма ===
Описание алгоритма на псевдокоде:
<source lang=cpp>
MST_Cluster(object[n] objects){
g = Pairs(objects, metric);
mst = Create_MST(graph);
parts = Split_MST(mst);
for i in range(parts){
clusters[i] = parts[i].vertices;
}
return clusters
}

</source>
=== Последовательная сложность алгоритма ===
Последовательная сложность алгоритма определяется самой сложной его частью (см. пункт 1.3) и равна <math>O(n^2*log(n^2))</math>.
=== Информационный граф ===
[[Файл:MST_cluster.png|thumb|center|1043px|Информационный граф алгоритма. Показана последовательная реализация (большой прямоугольник) и схема распараллеливания алгоритма построения минимального покрывающего дерева.]]
=== Ресурс параллелизма алгоритма ===
Ресурс параллелизма алгоритма основан на свойстве ассоциативности рёбер: 
Пусть <math>MSF(E)</math> – минимальный остовный лес (множество покрывающих деревьев) графа с рёбрами <math>E</math>. Тогда
:<math>
MSF(E_1 \cup E_2 \cup \dots \cup E_k) = MSF(MSF(E_1) \cup MSF(E_2) \cup \dots \cup MSF(E_k)).
</math>

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

Сложность параллельного алгоритма зависит от соотношения объёма входных данных и числа процессов. Существуют распределённые алгоритмы построения минимального покрывающего дерева, имеющие асимптотическую сложность <math>O(n*log(n))</math>. Эта же оценка будет выполняться и для всего алгоритма кластеризации.

=== Входные и выходные данные алгоритма ===
На вход алгоритму подаются объекты <math>(o_1, o_2, ..., o_n)</math>. 
Выходом алгоритма является множество непересекающихся кластеров: <math>C=(C_1, C_2, ..., C_k); C_i = (o_{i,1}, o_{i,2}, ..., o_{i, n_i}); o(i, l) \ne o(j, m); i \ne j; \forall l, m; \sum{n_i} = n </math>.
=== Свойства алгоритма ===
Важным свойством алгоритма является то, что при его распараллеливании по описанной выше стратегии важно правильно выбирать количество процессов. При увеличении количества процессов возрастают затраты на фазу слияния деревьев, полученных каждым процессом: растёт число этапов, в которые производится слияние, а следовательно, возрастают затраты на коммуникацию между процессами, и распределение нагрузки становится более неравномерным из-за того, что часть процессов должна проделать значительно большее количество работы по слиянию деревьев. 
Вычислительная мощность алгоритма имеет порядок <math>O(n*log(n^2))</math>. 
Ещё одним важным свойством алгоритма является его детерминированность в том случае, если для данного набора векторов существует единственное минимальное покрывающее дерево: при использовании детерминированной стратегии разбиения его на поддеревья алгоритм получает единственный результат для каждого набора данных. Однако, время работы может отличаться в зависимости от начального распределения рёбер по процессам.
== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===
[[Файл:MST_cluster_time.png|thumb|center|600px|Время работы алгоритма в зависимости от числа процессов и объёма входных данных.]] 
[[Файл:Mst_scale2.PNG|thumb|center|600px|Время работы алгоритма при меньшем числе процессов и объёме входных данных.]] 
[[Файл:Mst_cluster_efficiency.PNG|thumb|center|600px|Эффективность распараллеливания алгоритма.]] 
На первом и втором графике на логарифмической шкале показана зависимость времени работы алгоритма от числа процессов. Приведены измерения для девфти наборов данных, различающихся количеством входных векторов: от 512 до 131072 элементов. Использовалась собственная реализация алгоритма, основанная на [https://github.com/gpiskas/MinSpanTree_Kruskal_MPI_OpenMP сторонней реализации] алгоритма построения минимального покрывающего дерева (без OpenMP-части для более точного измерения масштабируемости описанной выше архитектуры). Изменения относительно приведённой реализации в основном коснулись генерации входных данных для алгоритма построения остовного дерева: в качестве функции расстояния между элементами при генерации графа бралось случайное число от 0 до 1. Изменения времени работы алгоритма при разных запусках (и, соответственно, с другим набором случайных чисел) незначительны. 
Полный текст изменённой части программы расположен по адресу [http://pastebin.com/5US84UgR]. 
Запуск проводился на аппаратной платформе [http://hpc.cmc.msu.ru/bgp IBM BlueGene/P]. Для каждого размера входных данных были проведены четыре теста: на 128, 256, 512 и 1024 вычислительных узлах соответственно. При дальнейшем увеличении объёма данных время выполнения программы превысило доступный предел (15 минут для 128 узлов). 
На третьем графике показана зависимость эффективности распараллеливания алгоритма в зависимости от числа вычислительных уздов и объёма входных данных. Видно, что эффективность быстро падает для малого объёма входных данных (из-за возрастающих затрат на обмен информацией) и остаётся высокой на графе из 2048 вершин. 

=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===
Основным вычислительным ядром алгоритма является алгоритм построения минимального покрывающего (остовного) дерева, применяющийся для многих задач, и многие библиотеки ограничиваются его реализацией, без реализации основанного на нём алгоритма кластеризации. Примеры реализаций алгоритмов построения MST:
* С++: [http://www.boost.org/doc/libs/1_62_0/libs/graph/doc/ Boost graph library] (алгоритмы Борувки и Крускала)
* C++, MPI: [http://www.boost.org/doc/libs/1_62_0/libs/graph_parallel/doc/html/index.html Parallel boost graph library] (алгоритм Борувки)
* Java: [http://jgrapht.org/ JGraphT] (алгоритмы Крускала и Прима)
* Python: [http://docs.scipy.org/doc/scipy-0.15.1/reference/index.html SciPy]
== Литература ==
# Нейский И.М. Классификация и сравнение методов кластеризации 
# C. Kingsford. Minimum Spanning Trees & Clustering ([https://www.cs.umd.edu/class/fall2009/cmsc451/lectures/Lec07a-mst.pdf])
# Y. Zhou et al. Clustering with Minimum Spanning Trees

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

2016-12-06T12:28:32Z

Zhum:

п. 2.4

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

Участник:Sarseev/Алгоритм кластеризации, основанный на минимальном покрывающем дереве

2016-12-06T12:25:50Z

Zhum:

Zhum}}

'''Автор''': Арсеев С. П., группа 620

== Свойства и структура алгоритма ==
=== Общее описание алгоритма ===
Данный алгоритм нацелен на решение задачи кластеризации, то есть, разделения множества объектов на группы, называемые кластерами, так, чтобы внутри одного кластера оказались наиболее похожие (по некоторой метрике) друг на друга объекты, а объекты из разных кластеров как можно сильнее отличались друг от друга.
Сам алгоритм состоит из следующих шагов:
# Сведение набора объектов к графу. Объекты становятся вершинами графа, и каждые две вершины соединяются ребром, длина которого равняется расстоянию между этими объектами по некоторой метрике. Выбор метрики зависит от предметной области и желаемых свойств алгоритма. Например, метрикой может служить евклидово расстояние.
# Построение минимального покрывающего (остовного) дерева в этом графе. Более подробно этот шаг описан в [[Построение_минимального_остовного_дерева_(MST)|соответствующей статье]].
# Кластеризация путём удаления некоторого количества рёбер в этом дереве. В случае, если заранее известно количество кластеров <math>k</math>, достаточно удалить <math>k-1</math> ребро с наибольшей длиной, чтобы получить <math>k</math> связных компонент, которые объявляются кластерами. Если же количество кластеров заранее не известно, удаляются рёбра с длиной больше некоторого порога, задаваемого как параметр алгоритма. Возможны и более сложные стратегии выбора рёбер для отсечения.
=== Математическое описание алгоритма ===
На вход алгоритму подаётся <math>n</math> объектов <math>a</math>, которые нужно кластеризовать. Каждый такой объект можно рассматривать как вектор или элемент некоторого метрического пространства. На пространстве, которому принадлежат <math>a</math>, задана метрика <math>d_{ij}=d(a_i,a_j)</math>. 
Первый шаг алгоритма строит граф <math>G=(V,E)</math>, где <math>V</math> - множество вершин графа <math>(|V|=n)</math>, а <math>E</math> - множество его рёбер <math>(|E| = \frac{n*(n-1)}{2})</math>. 
На втором этапе строится минимальное покрывающее дерево <math>MST(G)</math>. После удаления рёбер дерево распадается на поддеревья <math>MST_i</math>. Вершины, входящие в <math>i</math>-е поддерево, объявляются принадлежащими кластеру с номером <math>i</math>.
=== Вычислительное ядро алгоритма ===
Алгоритм состоит из трёх этапов:
# Преобразование исходных данных. Сложность <math>O(n^2)</math>.
# Поиск минимального покрывающего дерева. Последовательная сложность всех трёх основных алгоритмов ([[Алгоритм_Борувки|Борувки]], [[Алгоритм_Крускала|Крускала]] и [[Алгоритм_Прима|Прима]]) <math>O(|E|*log(|E|)) = O(n^2*log(n^2))</math>.
# Разбиение на кластеры. Вычислительная сложность <math>O(n)</math> для простых стратегий разбиения.
Таким образом, вычислительным ядром алгоритма является алгоритм построения минимального покрывающего дерева, поскольку он имеет наибольшую сложность. Стратегии распараллеливания алгоритма основаны на распараллеливании алгоритма построения минимального покрывающего дерева.
=== Макроструктура алгоритма ===
В состав алгоритма входит алгоритм [[Построение_минимального_остовного_дерева_(MST)|построения минимального покрывающего дерева]], являющийся его вычислительным ядром. Также в отдельную часть можно выделить алгоритм разбиения получившегося покрывающего дерева на кластеры.
=== Схема реализации последовательного алгоритма ===
Описание алгоритма на псевдокоде:
<source lang=cpp>
MST_Cluster(object[n] objects){
g = Pairs(objects, metric);
mst = Create_MST(graph);
parts = Split_MST(mst);
for i in range(parts){
clusters[i] = parts[i].vertices;
}
return clusters
}

</source>
=== Последовательная сложность алгоритма ===
Последовательная сложность алгоритма определяется самой сложной его частью (см. пункт 1.3) и равна <math>O(n^2*log(n^2))</math>.
=== Информационный граф ===
[[Файл:MST_cluster.png|thumb|center|1043px|Информационный граф алгоритма. Показана последовательная реализация (большой прямоугольник) и схема распараллеливания алгоритма построения минимального покрывающего дерева.]]
=== Ресурс параллелизма алгоритма ===
Ресурс параллелизма алгоритма основан на свойстве ассоциативности рёбер: 
Пусть <math>MSF(E)</math> – минимальный остовный лес (множество покрывающих деревьев) графа с рёбрами <math>E</math>. Тогда
:<math>
MSF(E_1 \cup E_2 \cup \dots \cup E_k) = MSF(MSF(E_1) \cup MSF(E_2) \cup \dots \cup MSF(E_k)).
</math>

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

Сложность параллельного алгоритма зависит от соотношения объёма входных данных и числа процессов. Существуют распределённые алгоритмы построения минимального покрывающего дерева, имеющие асимптотическую сложность <math>O(n*log(n))</math>. Эта же оценка будет выполняться и для всего алгоритма кластеризации.

=== Входные и выходные данные алгоритма ===
На вход алгоритму подаются объекты <math>(o_1, o_2, ..., o_n)</math>. 
Выходом алгоритма является множество непересекающихся кластеров: <math>C=(C_1, C_2, ..., C_k); C_i = (o_{i,1}, o_{i,2}, ..., o_{i, n_i}); o(i, l) \ne o(j, m); i \ne j; \forall l, m; \sum{n_i} = n </math>.
=== Свойства алгоритма ===
Важным свойством алгоритма является то, что при его распараллеливании по описанной выше стратегии важно правильно выбирать количество процессов. При увеличении количества процессов возрастают затраты на фазу слияния деревьев, полученных каждым процессом: растёт число этапов, в которые производится слияние, а следовательно, возрастают затраты на коммуникацию между процессами, и распределение нагрузки становится более неравномерным из-за того, что часть процессов должна проделать значительно большее количество работы по слиянию деревьев. 
Вычислительная мощность алгоритма имеет порядок <math>O(n*log(n^2))</math>. 
Ещё одним важным свойством алгоритма является его детерминированность в том случае, если для данного набора векторов существует единственное минимальное покрывающее дерево: при использовании детерминированной стратегии разбиения его на поддеревья алгоритм получает единственный результат для каждого набора данных. Однако, время работы может отличаться в зависимости от начального распределения рёбер по процессам.
== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===
[[Файл:MST_cluster_time.png|thumb|center|600px|Время работы алгоритма в зависимости от числа процессов и объёма входных данных.]] 
[[Файл:Mst_scale2.PNG|thumb|center|600px|Время работы алгоритма при меньшем числе процессов и объёме входных данных.]] 
[[Файл:Mst_cluster_efficiency.PNG|thumb|center|600px|Эффективность распараллеливания алгоритма.]] 
На первом и втором графике на логарифмической шкале показана зависимость времени работы алгоритма от числа процессов. Приведены измерения для девфти наборов данных, различающихся количеством входных векторов: от 512 до 131072 элементов. Использовалась собственная реализация алгоритма, основанная на [https://github.com/gpiskas/MinSpanTree_Kruskal_MPI_OpenMP сторонней реализации] алгоритма построения минимального покрывающего дерева (без OpenMP-части для более точного измерения масштабируемости описанной выше архитектуры). Изменения относительно приведённой реализации в основном коснулись генерации входных данных для алгоритма построения остовного дерева: в качестве функции расстояния между элементами при генерации графа бралось случайное число от 0 до 1. Изменения времени работы алгоритма при разных запусках (и, соответственно, с другим набором случайных чисел) незначительны. 
Полный текст изменённой части программы расположен по адресу [http://pastebin.com/5US84UgR]. 
Запуск проводился на аппаратной платформе [http://hpc.cmc.msu.ru/bgp IBM BlueGene/P]. Для каждого размера входных данных были проведены четыре теста: на 128, 256, 512 и 1024 вычислительных узлах соответственно. При дальнейшем увеличении объёма данных время выполнения программы превысило доступный предел (15 минут для 128 узлов). 
На третьем графике показана зависимость эффективности распараллеливания алгоритма в зависимости от числа вычислительных уздов и объёма входных данных. Видно, что эффективность быстро падает для малого объёма входных данных (из-за возрастающих затрат на обмен информацией) и остаётся высокой на графе из 2048 вершин. 

=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===
Основным вычислительным ядром алгоритма является алгоритм построения минимального покрывающего (остовного) дерева, применяющийся для многих задач, и многие библиотеки ограничиваются его реализацией, без реализации основанного на нём алгоритма кластеризации. Примеры реализаций алгоритмов построения MST:
* С++: [http://www.boost.org/doc/libs/1_62_0/libs/graph/doc/ Boost graph library] (алгоритмы Борувки и Крускала)
* C++, MPI: [http://www.boost.org/doc/libs/1_62_0/libs/graph_parallel/doc/html/index.html Parallel boost graph library] (алгоритм Борувки)
* Java: [http://jgrapht.org/ JGraphT] (алгоритмы Крускала и Прима)
* Python: [http://docs.scipy.org/doc/scipy-0.15.1/reference/index.html SciPy]
== Литература ==
# Нейский И.М. Классификация и сравнение методов кластеризации 
# C. Kingsford. Minimum Spanning Trees & Clustering ([https://www.cs.umd.edu/class/fall2009/cmsc451/lectures/Lec07a-mst.pdf])
# Y. Zhou et al. Clustering with Minimum Spanning Trees

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

2016-12-06T12:25:20Z

Zhum:

п 2.4

Примечание: задержка с последней правкой вызвана трёхдневным перебоем в работе системы BlueGene, из-за чего было невозможно доделать недостающие графики. --[[Участник:Sarseev|Сергей Арсеев]] ([[Обсуждение участника:Sarseev|обсуждение]]) 22:24, 3 декабря 2016 (MSK)

* нет пояснений к первым двум графикам - нужно нечто аналогичное пояснению третьего.

Участник:Parkhomenko/Алгоритм k средних

2016-12-01T10:38:41Z

Zhum:

{{Assignment|Zhum}}
{{algorithm
| name = Алгоритм k средних
| serial_complexity = <math>O(tnkd)</math>
| input_data = <math>nd</math>
| output_data = <math>n</math>
| pf_height = <math>O(t * \log kdn)</math>
| pf_width = <math>O(kdn)</math>
}}

Основные авторы описания: [[Участник:Parkhomenko|П.А.Пархоменко]] ([[#Общее описание алгоритма|1.1]], [[#Вычислительное ядро алгоритма|1.3]], [[#Последовательная сложность алгоритма|1.6]], [[#Ресурс параллелизма алгоритма|1.8]], [[#Входные и выходные данные алгоритма|1.9]], [[#Свойства алгоритма|1.10]], [[#Масштабируемость алгоритма и его реализации|2.4]]), [[Участник:Ivan.mashonskiy|И.Д.Машонский]] ([[#Математическое описание алгоритма|1.2]], [[#Макроструктура алгоритма|1.4]], [[#Схема реализации последовательного алгоритма|1.5]], [[#Информационный граф|1.7]], [[#Ресурс параллелизма алгоритма|1.8]], [[#Свойства алгоритма|1.10]], [[#Существующие реализации алгоритма|2.7]])
== Свойства и структура алгоритмов ==

=== Общее описание алгоритма ===
Алгоритм k средних (англ. k-means) - один из алгоритмов машинного обучения, решающий задачу кластеризации. Он был изобретен в середине 1950-х математиком Гуго Штейнгаузом<ref>Steinhaus H. (1956). Sur la division des corps materiels en parties. Bull. Acad. Polon. Sci., C1. III vol IV: 801—804.</ref> и Стюартом Ллойдом<ref>Lloyd S. (1957). Least square quantization in PCM’s. Bell Telephone Laboratories Paper.</ref>. Алгоритм стал особо популярным после публикации Маккуина<ref>MacQueen J. (1967). Some methods for classification and analysis of multivariate observations. In Proc. 5th Berkeley Symp. on Math. Statistics and Probability, pages 281—297.</ref>, в которой впервые был использован термин “k-means”.

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

K-means является итерационным алгоритмом, разновидностью EM-алгоритма. Основная идея работы алгоритма заключается в проведении некоторого количества итераций, на каждой из которых происходит пересчет центра масс для каждого кластера, полученного на предыдущей итерации. После этого векторы перераспределяются по кластерам: вектор относится к тому кластеру, расстояние до центра масс которого минимально. Алгоритм завершает работу в том случае, если на очередной итерации центры масс кластеров не изменились.

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

Исходные данные: множество d-мерных векторов (наблюдений) <math>X</math> = <math>\{x_1, x_2, ..., x_n\}</math>, число кластеров <math>k \in \mathbb{N}</math>

В результате работы алгоритма исходное множество векторов <math>X</math> разбивается на <math>k</math> непересекающихся множеств (кластеров) <math>S_1, S_2, ..., S_k</math>, таких что <math>X = {\bigcup \limits _{i = 1}^k S_i} </math> и значение <math>\sum_{i=1}^{k} \sum_{\mathbf x \in S_i} \left\| \mathbf x - \mu_i \right\|^2 </math> — минимально для всех возможных наборов <math>S_1, S_2, ..., S_k</math>.
Под <math>\mu_i</math> здесь подразумевается центр масс векторов из множества <math>S_i</math>.

Первоначальные значения центров масс <math>\mu_1^{(1)}, ..., \mu_k^{(1)}</math> определяются в начале работы алгоритма случайным образом среди векторов множества <math>X</math>.

Алгоритм заключается в попеременном применении двух шагов <ref>MacKay, David (2003). "Chapter 20. An Example Inference Task: Clustering" (PDF). Information Theory, Inference and Learning Algorithms. Cambridge University Press. pp. 284–292.</ref>: '''распределения''' векторов по кластерам и '''обновления''' центров масс каждого кластера

'''Распределение векторов по кластерам''': на данном шаге каждый вектор распределяется в один из кластеров <math>S_i^{(t)}</math>:
::<math>S_i^{(t)} = \big \{ x_p : \big \| x_p - \mu^{(t)}_i \big \|^2 \le \big \| x_p - \mu^{(t)}_j \big \|^2 \ \forall j, 1 \le j \le k \big\},</math>
'''Обновление центров масс''': на данном шаге вычисляются новые центры масс для кластеров, полученных на предыдущем шаге.
::<math>\mu^{(t+1)}_i = \frac{1}{|S^{(t)}_i|} \sum_{x_j \in S^{(t)}_i} x_j </math>

Алгоритм завершается, когда на очередном шаге не происходит изменения центров масс кластеров.

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

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

Для соотнесения вектора к одному из кластеров, необходимо для каждого из N вектора посчитать расстояние до центров масс всех K кластеров. Для нахождения расстояния между двумя d-мерными векторами p и q используется Евклидова метрика: <math>\sqrt{\sum_{k=1}^d (p_k-q_k)^2}</math>

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

Инициализация центров масс кластеров

В начале алгоритма осуществляется инициализация центров масс <math>\mu_1^{(1)}, ..., \mu_k^{(1)}</math>, которая может быть реализована двумя возможными способами <ref>Hamerly, G.; Elkan, C. (2002). "Alternatives to the k-means algorithm that find better clusterings" (PDF). Proceedings of the eleventh international conference on Information and knowledge management (CIKM).</ref>:
* случайный выбор центров масс среди исходных наблюдений <math>x_1, x_2, ..., x_n</math>;
* все наблюдения случайным образом распределяются по кластерам <math>S_1, S_2, ..., S_k</math>, а затем для каждого кластера выполняется операция обновления центра масс.

Распределение векторов по кластерам

На шаге распределения векторов по кластерам производится операция нахождения квадратов расстояний между векторами кластера и центром масс кластера:
::<math>\rho = \big \| x_p - \mu^{(t)}_i \big \|^2</math>

Обновление центров масс кластеров

На шаге обновления центров масс производится операция суммирования векторов кластера:
::<math>\mu^{(t+1)}_i = \frac{1}{|S^{(t)}_i|} \sum_{x_j \in S^{(t)}_i} x_j </math>

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

Последовательность исполнения метода следующая:
# Инициализируются центры масс <math>\mu_1^{(1)}, ..., \mu_k^{(1)}</math>
# <math>t := 1</math>
# Для каждого вектора <math>x_i, i = 1, 2, ..., n</math> вычисляется <math>m = \underset{j \in \{1, 2, ..., k\}} {\operatorname{arg\,min}} \big \| x_i - \mu^{(t)}_j \big \|^2</math>, вектор <math>x_i</math> распределяется в кластер <math>S^{(t)}_m</math>
# Для каждого <math>j = 1, 2, ..., k</math> вычисляется <math>\mu^{(t+1)}_j = \frac{1}{|S^{(t)}_i|} \sum_{x_j \in S^{(t)}_i} x_j </math>
# Если <math>\mu^{(t)}_j = \mu^{(t+1)}_j, j = 1, 2, ..., k</math>, завершить выполнение алгоритма, иначе <math>t := t + 1</math>, переход на шаг 3.

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

Для вычисления центра массы кластера, содержащего <math>n_i</math> d-мерных векторов, необходимо:
* <math>n_i * (d - 1)</math> операций сложения
* <math>d</math> операций деления

Для определения центров масс всех k кластеров требуется:
* <math>n * (d - 1)</math> операций сложения
* <math>k * d</math> операций деления

Для определения расстояния между двумя d-мерными векторами, требуется:
* <math>d</math> операций вычитания
* <math>d</math> операций умножения
* <math>d - 1</math> операций сложения

Для определения кластера для n d-мерного векторов, необходимо:
* <math>n * k * d</math> операций вычитания
* <math>n * k * d</math> операций умножения
* <math>n * k * (d - 1)</math> операций сложения

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

Сложность всего алгоритма, состоящего из <math>t</math> итераций: <math>O(t * n * k * d)</math>

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

В данном разделе описывается информационный граф алгоритма k-средних при <math>n = 3, k = 2</math>

На рисунке 1 показана общая структура алгоритма: в качестве входных данных выступает матрица, строками которой являются входные векторы <math>x_1, x_2, x_3</math>, на выходе получается массив из <math>n</math> чисел, где элемент с номером <math>i = 1, 2, 3</math> обозначает номер кластера, которому принадлежит вектор <math>x_i</math>. На шаге <math>init</math> происходит инициализация значений центров масс кластеров, после этого осуществляется итеративное повторение этапов распределения векторов по кластерам (<math>as</math>) и обновления значений центров масс кластеров (<math>up</math>). Когда на очередном шаге обновления центров масс кластеров значения центров масс не изменяются, алгоритм завершает работу, и в качестве выходных данных выступают номера кластеров для каждого из входных векторов.
[[file:k_means_main.png|thumb|center|400px|Рисунок 1. Общая схема работы алгоритма k-средних]]

'''Распределение векторов по кластерам.''' На рисунке 2 изображен информационный граф для этапа распределения векторов по кластерам. В качестве входных данных выступают строки входной матрицы (входные векторы) <math>x_1, x_2, x_3</math> и текущие значения центров масс кластеров <math>\mu_1, \mu_2</math> (вычисленные на этапе инициализации или предшествующего этапа обновления центров масс кластеров). В качестве выходных данных выступают числа <math>m_1, m_2, m_3</math>, где <math>m_i, i = 1, 2, 3</math> - номер кластера, содержащего вектор <math>x_i</math>. Вершинами с пометкой <math>sub</math> обозначены операции векторной разности, вершинами <math>sn</math> - операция вычисления квадрата нормы вектора, вершинами <math>am</math> - операция <math>\underset{i \in \{1, 2\}} {\operatorname{arg\,min}} p_i</math>.
[[file:k_means_info_graph_as.png|thumb|center|400px|Рисунок 2. Граф алгоритма для этапа распределения векторов по кластерам]]
'''Обновление центров масс кластеров.''' На рисунке 3 представлен информационный граф для этапа обновления центров масс кластеров. В качестве входных данных выступают строки входной матрицы (входные векторы) <math>x_1, x_2, x_3</math> с соответствующими номерами кластеров <math>m_1, m_2, m_3</math>, содержащих эти векторы. В качестве выходных данных здесь выступают обновленные значения центров масс кластеров: <math>\mu_1, \mu_2</math>. Вершинами с пометками <math>s_i, i = 1, 2</math> обозначены операции суммирования векторов, принадлежащих кластеру <math>i</math>. Вершинами с пометками <math>cs_i, i = 1, 2</math> обозначены операции вычисления выражения <math>1 / |S_i|</math>, где за <math>S_i</math> обозначен кластер с номером <math>i</math>. Вершинами с пометкой <math>p</math> обозначена операция произведения.
[[file:k_means_info_graph_up.png|thumb|center|400px|Рисунок 3. Граф алгоритма для этапа обновления центров масс кластеров]]

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

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

В силу особенностей алгоритма k средних порядок выполнения основных этапов существенен, что не позволяет выполнять их параллельно. Таким образом, итоговая сложность параллельного алгоритма будет определяться, исходя из формулы <math>T = t * (T_{as} + T_{up})</math>, где <math>T_{as}</math> - параллельная сложность этапа распределения векторов по кластерам, <math>T_{up}</math> - параллельная сложность этапа обновления центров масс кластеров, <math>t</math> - общее число итераций алгоритма.

Параллельная сложность этапа распределения векторов по кластерам с учетом доступности неограниченного числа процессоров вычисляется следующим образом: так как вычисление значений <math>\big \| x_i - \mu^{(t)}_j \big \|^2</math> для каждой пары векторов <math>x_i, i = 1, 2, ..., n</math> и <math>\mu^{(t)}_j, j = 1, 2, ..., k</math> можно выполнять независимо и для вычисления этого выражения требуется <math>O(\log d)</math> операций в соответствии с [[Нахождение_частных_сумм_элементов_массива_сдваиванием | параллельной реализацией нахождения сумм элементов массива сдваиванием]]. Параллельная сложность реализации операции нахождения минимума из <math>k</math> элементов определяется как <math>O(\log k)</math>. Таким образом, сложность этапа распределения векторов по кластерам <math>O(\log kd)</math>.

Параллельная сложность этапа обновления центров масс кластеров вычисляется следующим образом: так как обновление значений каждого из центров масс кластеров можно выполнять независимо, параллельная сложность определяется сложностью обновления центра масс самого большого кластера. В худшем случае для нахождения значения выражения <math>\mu^{(t+1)}_j = \frac{1}{|S^{(t)}_i|} \sum_{x_j \in S^{(t)}_i} x_j </math> требуется <math>O(\log n)</math> операций.

С учетом вышесказанного, итоговая параллельная сложность алгоритма k средних определяется выражением <math>O(t * \log kdn)</math>.

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

'''Входные данные''':
* целое неотрицательное число <math>k</math> - количество кластеров;
* матрица координат векторов <math>A</math> размерностью <math>n * d</math>.

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

'''Выходные данные''':
* вектор длины <math>n</math> - для каждого вектора указан номер кластера.

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

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

Соотношение последовательной и параллельной сложности алгоритма равно <math>\frac{O(tnkd)}{O(t * \log kdn)}</math>.

Число операций алгоритма k средних оценивается как <math>O(tnkd)</math>, суммарный объем входных и выходных данных равен <math>n(d+1)</math>. Следовательно, вычислительная мощность алгоритма линейна по <math>k</math> и линейна по <math>t</math>.

Стоит отметить следующие ключевые особенности алгоритма k средних:
* Алгоритм прост в реализации и имеет высокую скорость работы по сравнению с другими алгоритмами кластеризации (при удачном выборе начальных значений центров масс кластеров)
* В качестве метрики используется евклидово расстояние, а в качестве меры разброса кластера используется дисперсия
* Количество кластеров k является входным параметром алгоритма, поэтому неправильный выбор этого параметра может негативно повлиять на качество кластеризации
* Сходимость алгоритма к локальному минимуму может породить некорректный конечный результат работы
* Алгоритм очень чувствителен к выбору начальных центров масс кластеров: классический вариант подразумевает случайный их выбор, что может являться источником погрешности. Из этого и предыдущего свойства следует то, что алгоритм не является устойчивым.

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

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

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

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

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

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

=== Масштабируемость алгоритма и его реализации ===
Исследование масштабируемости алгоритма k-means в зависимости от количества используемых процессов было проведено в статье Кумара<ref>Kumar, J., Mills, R. T., Hoffman, F. M., & Hargrove, W. W. (2011). Parallel k-means clustering for quantitative ecoregion delineation using large data sets. Procedia Computer Science, 4, 1602-1611.</ref>. Исследование происходило на суперкомпьютере Jaguar - Cray XT5<ref>https://www.top500.org/system/176029</ref>. На момент экспериментов данный суперкомпьютер имел следующую конфигурацию: 18,688 вычислительных узлов с двумя шестнадцатиядерными процессорами AMD Opteron 2435 (Istanbul) 2.6 GHz, 16 GB of DDR2-800 оперативной памяти, и SeaStar 2+ роутер. Всего он состоял из 224,256 вычислительных ядер, 300 TB памяти, и пиковой производительностью 2.3 petaflops.

Реализация алгоритма была выполнена на языке программирования C с использованием MPI.

Объем данных составлял 84 гигабайта, количество объектов (d-мерных векторов) n равнялось 1,024,767,667, размерность векторов d равнялась 22, количество кластеров k равнялось 1000.

На рисунке 4 показана зависимости времени работы алгоритма кластеризации k-means в зависимости от количества используемых процессоров. Можно отметить, что время, затраченное на чтение данных и запись результатов кластеризации, практически не изменяется с увеличением количества задействованных процессоров. Время же работы самого алгоритма кластеризации уменьшается с увеличением количества процессоров.
[[Файл:k-means-proc-scalability.png|thumb|center|700px|Рисунок 4. Зависимости времени работы алгоритма кластеризации k-means в зависимости от количества используемых процессоров.]]

Также было произведено самостоятельное исследование масштабируемости алгоритма. Исследование производилось на суперкомпьютере "Blue Gene/P"<ref>http://hpc.cmc.msu.ru/bgp</ref>.

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

* число процессоров [1, 2, 4, 8, 16, 32, 64, 128, 256, 512];
* количество объектов [5000, 10000, 25000, 50000].

Был использован набор данных ''Dataset for Sensorless Drive Diagnosis Data Set''<ref>PASCHKE, Fabian ; BAYER, Christian ; BATOR, Martyna ; MÃ–NKS, Uwe ; DICKS, Alexander ; ENGE-ROSENBLATT, Olaf ; LOHWEG, Volker: Sensorlose ZustandsÃ¼berwachung an Synchronmotoren, Bd. 46. In: HOFFMANN, Frank; HÃœLLERMEIER, Eyke (Hrsg.): Proceedings 23. Workshop Computational Intelligence. Karlsruhe : KIT Scientific Publishing, 2013 (Schriftenreihe des Instituts fÃ¼r Angewandte Informatik - Automatisierungstechnik am Karlsruher Institut fÃ¼r Technologie, 46), S. 211-225</ref> из репозитория ''Machine learning repository''<ref>https://archive.ics.uci.edu/ml/datasets/Dataset+for+Sensorless+Drive+Diagnosis</ref>.

Исследуемый набор данных содержит векторы, размерность которых равна 49. Компоненты векторов являются вещественными числами. Количество кластеров равно 11. Пропущенные значения отсутствуют.

Для исследования масштабируемости алгоритма была использована реализация на языке C с использованием MPI<ref>http://users.eecs.northwestern.edu/~wkliao/Kmeans/index.html</ref>. Код можно найти здесь: https://github.com/serban/kmeans.

На рисунке 5 показана зависимости времени работы алгоритма кластеризации k-means в зависимости от количества используемых процессоров. Можно видеть, что при увеличении количества процессоров в N раз, время работы алгоритма уменьшается примерно в N раз (при условии, что количество объектов остается неизменным). Также можно отметить, что при фиксированном количестве процессоров, зависимость времени работы алгоритма от количества объектов также близка к линейной.
[[Файл:Heatmap_kmeans.png|thumb|center|900px|Рисунок 5. Зависимости времени работы алгоритма кластеризации k-means в зависимости от количества используемых процессоров.]]

На рисунке 6 показана зависимости времени работы алгоритма кластеризации k-means в зависимости от количества используемых процессоров (при фиксированном количестве объектов, равном 50000). При визуализации была использована логарифмическая шкала. Можно отметить, что при заданном наборе данных можно наблюдать линейную зависимость времени работы алгоритма от количества используемых процессоров, что согласуется с теоретической оценкой сложности последовательной версии алгоритма.
[[Файл:50000kmeans.png|thumb|center|900px|Рисунок 6. Зависимости времени работы алгоритма кластеризации k-means в зависимости от количества используемых процессоров (количество объектов равно 50000).]]

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

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

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

Существуют следующие реализации алгоритма k-средних:
* [http://scikit-learn.org/ scikit-learn] библиотека машинного обучения для языка Python.
* [https://www.scipy.org/ SciPy] библиотека на языке Python, содержащая большое число реализаций различных алгоритмов, в том числе ''k''-средних.
* [http://elki.dbs.ifi.lmu.de ELKI] библиотека для анализа данных на языке программирования Java, содержит различные алгоритмы кластеризации, в том числе ''k''-средних.
* [http://mlpack.org MLPACK] библиотека машинного обучения для C++, содержит реализацию алгоритма ''k''-средних.
* [https://github.com/JuliaStats/Clustering.jl Julia k-means] реализация алгоритма ''k''-средних на языке программирования Julia.
* [http://opencv.org/ OpenCV] библиотека содержит реализацию ''k''-средних.
* [http://mahout.apache.org Apache Mahout] содержит реализацию алгоритма ''k''-средних на базе MapReduce.
* [http://www.cs.waikato.ac.nz/~ml/weka Weka] библиотека и инструмент для анализа данных на языке Java.
* [http://torch.ch/ Torch] библиотека машинного обучения на базе языка программирования Lua.
* [https://spark.apache.org/ Apache Spark MLlib] содержит распределенную реализацию алгоритма ''k''-средних.
* [http://www.accord-framework.net/ Accord.NET] содержит несколько различных реализаций ''k''-средних на языке C#.
* [https://www.r-bloggers.com/k-means-clustering-in-r/ R k-means] реализация ''k''-средних на языке R.

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

Участник:IanaV/Алгоритм k means

2016-11-29T08:28:25Z

Zhum:

{{Assignment|Zhum}}

{{level-a}}
Авторы страницы: [[Участник:IanaV|Валуйская Я.А.]], [[Участник:GlotovES|Глотов Е.С.]]

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

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

=== Общее описание алгоритма ===
Алгоритм k-means (k средних) - один из наиболее популярных алгоритмов кластеризации. Наиболее простой, но в то же время достаточно неточный метод кластеризации в классической реализации.
Алгоритм был разработан в 1956 году математиком Гуго Штейнгаузом <ref>[http://www.laurent-duval.eu/Documents/Steinhaus_H_1956_j-bull-acad-polon-sci_division_cmp-k-means.pdf Steinhaus H. (1956). Sur la division des corps materiels en parties. Bull. Acad. Polon. Sci., C1. III vol IV: 801—804.]</ref>, и почти одновременно его изобрел Стюарт Ллойд <ref>[http://www-evasion.imag.fr/people/Franck.Hetroy/Teaching/ProjetsImage/2007/Bib/lloyd-1982.pdf Lloyd S. (1957). Least square quantization in PCM’s. Bell Telephone Laboratories Paper.]</ref>. Особую популярность алгоритм снискал после работы Джеймса Маккуина <ref>[https://pdfs.semanticscholar.org/a718/b85520bea702533ca9a5954c33576fd162b0.pdf MacQueen J. (1967). Some methods for classification and analysis of multivariate observations. In Proc. 5th Berkeley Symp. on Math. Statistics and Probability, pages 281—297.]</ref>
Алгоритм кластеризации k-means решает задачу распределения <math>N</math> наблюдений (элементов векторного пространства) на заранее известное число кластеров <math>K</math>. Действие алгоритма таково, что он стремится минимизировать среднеквадратичное отклонение на точках каждого кластера.
Алгоритм k-means является итерационным алгоритмом кластеризации. На каждой итерации происходит пересчет центра масс для каждого кластера, полученного на предыдущем шаге, затем исходные векторы заново распределяются по кластерам в соответствии с тем, какой из новых центров оказался ближе по выбранной метрике. Алгоритм завершается, когда на какой-то итерации не происходит изменения кластеров.

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

''Исходные данные:''
* множество наблюдений <math>X = \{x_1, x_2, ..., x_n\}</math>, где каждое наблюдение <math>x_i \in R^d, i = 1, ..., n</math>;
* количество кластеров <math>k \in N, k \leq n</math>

''Обозначения:''
* <math>S = \{S_1, S_2, ..., S_k \} </math> - множество кластеров, которые удовлетворяют следующим условиям:
** <math>S_i \bigcap S_j = \emptyset, i \neq j</math>;
** <math>X = {\bigcup \limits _{i = 1}^k S_i} </math>.
* <math>\mu_i \in R^d, i = 1, ..., k</math> - центр масс кластера <math>S_i</math>
* <math>d(u, v)</math> - расстояние между векторами <math>u \in R^m, v \in R^m</math>

''Выходные данные:''
* <math>L = (l_1, l_2, ..., l_n)</math> - набор меток, где метка <math>l_i \in N_{[1, k]}</math> - является порядковым номером кластера, к которому принадлежит вектор <math>x_i</math>: <math> x_i \in S_{l_i}</math>

 ''Цель алгоритма k-means'' - распределить наблюдения из входного множества <math>X</math> по <math>k</math> кластерам <math>S = \{S_1, S_2, ..., S_k \} </math> таким образом, чтобы сумма квадратов расстояний от каждой точки кластера до его центра масс по всем кластерам была минимальной:

<math>\arg\min_{S} \sum_{i=1}^{k} \sum_{x \in S_i} (d(x, \mu_i))^2 </math>,

Алгоритм состоит из следующих шагов:

# Инициализация центров масс На данном шаге задаются начальные значения центров масс <math> \mu_1^1, ..., \mu_k^1</math>. Существует несколько способов их выбора. Они будут рассмотрены ниже.
# t-ый шаг итерации:
#* Распределение векторов по кластерам На данном шаге каждый вектор <math>x_i \in X</math> распределяется в свой кластер <math>S_j^t</math> так, что: <math>l_i^t = \arg \min_{j} (d(x_i, \mu_j^t))^2 , j = 1, ..., k; i = 1, ..., n</math>
#* Пересчет центров масс кластеров На данном шаге происходит пересчет центров масс кластеров, полученных на предыдущем этапе: <math>\mu_i^{t+1} = \frac{1}{|S_i^t|} \sum_{x \in S_i^t} x</math>; <math>i = 1, ..., k</math>
# Критерий останова <math>\mu_i^t = \mu_i^{t+1},</math> для всех <math>i = 1, ..., k</math>

Способы инициализации начальных данных:
# Метод Forgy Случайным образом выбираются <math>k</math> векторов из множества наблюдений <math>X</math>. Эти вектора используются в качестве центров масс кластеров <math>\mu_1, ..., \mu_k</math>
# Метод случайного разбиения (Random Partition) <ref>[http://people.csail.mit.edu/tieu/notebook/kmeans/15_p600-hamerly.pdf Hamerly, G.; Elkan, C. (2002). "Alternatives to the k-means algorithm that find better clusterings". Proceedings of the eleventh international conference on Information and knowledge management (CIKM).]</ref> Каждый вектор <math>x_i, i = 1, .., n</math> случайным образом распределяется в кластер <math>S_j, j = 1, .., k</math>, затем для каждого кластера вычисляется его центр масс <math>\mu_j</math>.

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

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

Распределение векторов по кластерам заключается в следующем: для каждого вектора <math>x_i \in X, i = 1, ..., n</math> необходимо посчитать расстояние между этим вектором и центром масс кластера <math>\mu_j^t, j = 1, ..., k</math>. Следовательно, на каждой итерации необходимо выполнить <math>n * k</math> операций вычисления расстояния между векторами.

Пересчет центров масс кластеров заключается в следующем: для каждого кластера <math>S_i^t \in S, i = 1, ..., k</math> необходимо пересчитать кластер по формуле, приведенной в пункте выше. Следовательно, на каждой итерации необходимо выполнить <math>k</math> операций пересчета центров масс кластеров.

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

# Макрооперация "Расстояние между векторами" В данном алгоритме используется Евклидова метрика: <math>v \in R^m</math> и <math>u \in R^m: d(v, u) = \sqrt{\sum_{j=1}^{m} (v_j - u_j)^2} </math>;
# Макрооперация "Пересчет центра масс кластера" <math>\mu_i^{t+1} = \frac{1}{|S_i^t|} \sum_{x \in S_i^t} x</math>

Таким образом, алгоритм в терминах макроопераций выглядит следующим образом:
# Инициализация центров масс Метод Forgy: центры масс <math>\mu_j^1, j = 1, ..., k</math> выбираются случайным образом. Метод случайного разбиения: вектора <math>x_i \in X</math> случайным образом распределяются по кластерам. Для каждого кластера выполняется макрооперация "Пересчет центра масс кластера" для нахождения <math>\mu_j^1</math>.
# t-ый шаг итерации:
#* Распределение векторов по кластерам На данном шаге для каждого вектора <math>x_i \in X</math> k раз выполняется макрооперация "Расстояние между векторами" для нахождения расстояния между <math>x_i</math> и <math>\mu_j^t, j = 1, ..., k</math>. Затем для каждого вектора <math>x_i</math> находится минимальное расстояние.
#* Пересчет центров масс кластеров На данном шаге для каждого кластера выполняется макрооперация "Пересчет центра масс" для нахождения <math>\mu_j^{t+1}</math>.
# Критерий останова <math>\mu_i^t = \mu_i^{t+1},</math> для всех <math>i = 1, ..., k</math>

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

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

Входные данные : Множество векторов <math>X</math>, количество кластеров <math>k</math>
Выходные данные : Набор меток <math>L</math> принадлежности к кластеру
1 Инициализация центров масс <math>\mu_i^1, i = 1, ..., k</math>;
2 t := 1;
3 Для каждого вектора <math>x_i \in X, i = 1, ..., n:</math> <math>l_i^t = \arg \min_{j} (d(x_i,\mu_j^t))^2 , j = 1, ..., k</math>;
4 Для каждого кластера <math>S_i^t, i = 1, ..., k</math> выполняется макрооперация "Пересчет центра масс";
5 if (<math>\exists i = 1, ..., k: \mu_i^t \neq \mu_i^{t+1}</math>) {
6 t := t + 1;
7 goto 3;
8 } else {
9 stop;
10 };

Существующие способы оптимизации алгоритма <ref>[http://link.springer.com/chapter/10.1007/3-540-45643-0_13 Phillips S. J. Acceleration of k-means and related clustering algorithms //Workshop on Algorithm Engineering and Experimentation. – Springer Berlin Heidelberg, 2002. – С. 166-177.]</ref> <ref>[http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.187.3017&rep=rep1&type=pdf Hamerly G. Making k-means Even Faster //SDM. – 2010. – С. 130-140.]</ref> <ref>[http://cseweb.ucsd.edu/~elkan/kmeansicml03.pdf Elkan C. Using the triangle inequality to accelerate k-means //ICML. – 2003. – Т. 3. – С. 147-153.]</ref>

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

Подсчитаем количество операций для каждого шага алгоритма.

# Инициализация:
#* Метод Forgy: <math>N_{init} = 0</math>
#* Метод случайного разбиения:
#** Количество операций деления: <math>N^{/}_{init} = k * d</math>;
#** Количество операций сложения: <math>N^{+}_{init} = d * (n - k)</math>.
# Распределение <math>n</math> векторов <math>x_i \in R^d</math> по <math>k</math> кластерам на одной итерации:
#* Количество операций умножения: <math>N^{*}_{distr} = k * n * d</math>;
#* Количество операций сложения: <math>N^{+}_{distr} = k * n * (d - 1)</math>;
#* Количество операций вычитания: <math>N^{-}_{distr} = k * n * d</math>;
#* Количество операций взятия минимума: <math>N^{min}_{distr} = n * (k - 1)</math>.
# Пересчет центра масс <math>\mu_i \in R^d</math> для <math>k</math> кластеров на одной итерации:
#* Количество операций деления: <math>N^{/}_{update} = k * d</math>;
#* Количество операций сложения: <math>N^{+}_{update} = d * (n - k)</math>.

Следовательно, в случае если алгоритм сошелся за <math>i</math> итераций, получаем:
* Операций сложения/вычитания: <math>N^{+,-}_{k-means} = N^{+}_{init} + i*(N^{+}_{distr} + N^{-}_{distr} + N^{+}_{update}) = d * (n - k) + i*(k*n*(d-1)+k*n*d+d*(n-k)) \thicksim O(i*k*n*d)</math>
* Операций умножения/деления: <math>N^{*,/}_{k-means} = N^{/}_{init} + i*(N^{*}_{distr} + N^{/}_{update}) = k * d + i*(k*n*d+k*d) \thicksim O(i*k*n*d)</math>

Таким образом, [[глоссарий#Последовательная сложность|''последовательная сложность'']] алгоритма k-means для <math>n</math> <math>d</math>-мерных векторов и <math>k</math> кластеров за <math>i</math> итераций, требуемых для сходимости алгоритма: <math>O(i * n * k * d)</math>

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

Рассмотрим информационный граф алгоритма k-means.
На рисунке 1 представлена общая схема алгоритма k-means, согласно разделу [[#Схема реализации последовательного алгоритма|"Схема реализации последовательного алгоритма"]].
Вершина Init - этап инициализации.
Вершина Distribute - этап распределения векторов по кластерам.
Вершина Update - этап пересчета центров масс кластеров.
[[file:k-means-all.PNG|800px|thumb|center|Рисунок 1. Общая схема алгоритма k-means]]

На рисунке 2 представлен информационный граф этапа распределения векторов по кластерам. На вход данному этапу подают множество векторов <math>x_1, x_2, ..., x_n</math> из входных данных и множество центров масс кластеров <math>\mu^t_1, ..., \mu^t_k</math>, полученных с шага инициализации или с предыдущей итерации. Для каждой пары векторов <math>x_i, \mu^t_j, i = 1, ..., n; j = 1,..., k</math> считается расстояние между ними (вершина dist). Информационный граф вычисления расстояния между двумя векторами рассмотрен ниже (рисунок 3). Затем выполняется операция нахождения минимума (вершина min), в результате которой каждому вектору <math>x_i, i = 1, ..., n</math> приписывается метка <math>l^t_i</math>, равная порядковому номеру кластера <math>S^t_j, j = 1 ..., k</math>, которому принадлежит данный вектор: <math>x_i \in S^t_j</math>.
[[file:k-means-distribute.PNG|800px|thumb|center|Рисунок 2. Схема этапа распределения векторов по кластерам]]

На рисунке 3 представлен информационный граф вычисления расстояния между двумя векторами <math>x_i = (x_{i1}, ..., x_{id}), i = 1, ..., n</math> и <math>\mu^t_j = (\mu^t_{j1}, ..., \mu^t_{jd}) , j = 1, ..., k</math>. Выполняется операция поэлементного вычитания двух векторов (вершины -), затем возведение в квадрат (вершины sqr), затем суммирование полученных результатов (вершина +). На выходе получаем квадрат расстояния между векторами.
[[file:K-means-distance.PNG|800px|thumb|center|Рисунок 3. Схема вычисления расстояния между двумя векторами]]

На рисунке 4 представлен информационный граф этапа пересчета центров масс кластеров <math>\mu^t_1, \mu^t_2,..., \mu^t_k</math>. Для каждого кластера <math>S^t_j, j = 1, ..., k</math> выполняется операция суммирования (вершина <math>sum_j</math>) векторов, которые принадлежат данному кластеру. Кроме того, для каждого кластера выполняется операция определения количества элементов в нем (вершина <math>size_j</math>). Затем выполняется операция деления (вершина /). На выходе получаем новые центры масс кластеров <math>\mu^{t+1}_1, \mu^{t+1}_2,..., \mu^{t+1}_k</math>.
[[file:k-means-update.PNG|800px|thumb|center|Рисунок 4. Схема этапа пересчета центров масс кластеров]]

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

Вычислительное ядро алгоритма имеет большие возможности для параллелизма:
* Распределение векторов по кластерам: вектора <math>x_i, x_j, i \neq j; i, j = 1, ..., n</math> могут быть распределены по кластерам независимо друг от друга;
* Пересчет центров масс кластеров: центры масс кластеров <math>\mu_i, \mu_j, i \neq j; i, j = 1, ..., k</math> могут быть пересчитаны независимо друг от друга.

Однако, этап пересчета центров масс кластеров зависит от этапа распределения векторов по кластерам, так что эти этапы должны выполняться строго последовательно. Таким образом, параллельная сложность алгоритма может быть вычислена следующим образом: <math>N_{k-means} = i * (N_{distr} + N_{update})</math>, где <math>i</math> - количество итераций, необходимых для сходимости алгоритма, <math>N_{distr}</math> - параллельная сложность этапа распределения векторов по кластерам, <math>N_{update}</math> - параллельная сложность этапа пересчета центров масс кластеров.

Рассчитаем параллельную сложность <math>N_{distr}</math> этапа распределения векторов по кластерам в предположении наличия неограниченного числа процессоров для одной итерации. Для каждой пары векторов <math>(x_i, \mu_j), i = 1,...,n; j = 1, ..., k</math> операция вычисления расстояния выполняется независимо.
* При выполнении операция вычисления расстояния операции вычитания и умножения выполняются независимо друг от друга, поэтому требуется только одно вычитание и одно умножение. Число операций сложения: <math>N^{+}_{distr} = O(log(d))</math> согласно [[Нахождение_частных_сумм_элементов_массива_сдваиванием | алгоритму нахождения частичной суммы элементов массива путем сдваивания]];
* Для нахождения минимума среди <math>k</math> элементов требуется <math>O(log(k))</math> операций сравнения.
Таким образом, получаем, что <math>N_{distr} = O(log(k*d))</math>

Рассчитаем параллельную сложность <math>N_{update}</math> этапа пересчета центров масс кластеров в предположении наличия неограниченного числа процессоров для одной итерации. Нахождение центра масс <math>\mu_j, j = 1, ..., k</math> кластера <math>S_j</math> может выполняться независимо от нахождения центров масс других кластеров. Таким образом, получаем, что <math>N_{update} \leq O(log(n))</math> в худшем случае, когда почти все векторы находятся в одном кластере.

Итоговая параллельная сложность алгоритма: <math>N_{k-means} \leq i * (log(k*d) + log(n)) \thicksim O(i * log(k*d*n)); i</math> - количество итераций, необходимых для сходимости.

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

Входные данные:
* <math>n</math> векторов <math>x_i \in R^d, i = 1, ..., n</math>;
* число кластеров <math>k \in N_{[1,n]}</math>.

Объем входных данных:
<math>n * d</math> действительных чисел, 1 целое положительное число

Выходные данные:
* вектор меток <math>L \in N^n</math>.

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

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

;Достоинства:
# Алгоритм прозрачный и понятный, за счет чего очень прост в реализации;
# Алгоритм имеет высокую скорость работы в случае выбора оптимальных начальных значений центров масс кластеров.

;Недостатки:
# Число кластеров является входным аргументом алгоритма. Таким образом, некорректный выбор данного параметра может привести к плохим результатам работы алгоритма, поэтому зачастую проводят несколько прогонов алгоритма с разными значениями <math>k</math>, чтобы подобрать оптимальный;
# Алгоритм может сойтись к локальному минимуму (достижение глобального минимума не гарантируется);
# Результат сильно зависит от выбора начальных значений центров масс кластеров. Существует улучшенная версия алгоритма - k-means++ <ref>[http://ilpubs.stanford.edu:8090/778/1/2006-13.pdf Arthur, D.; Vassilvitskii, S. (2007). "k-means++: the advantages of careful seeding". Proceedings of the eighteenth annual ACM-SIAM symposium on Discrete algorithms. Society for Industrial and Applied Mathematics Philadelphia, PA, USA. pp. 1027–1035.]</ref>, которая предлагает свой способ нахождения начальных оптимальных значений центров масс кластеров;
# Чувствительность к выбросам и шумам, так как они учитываются при вычислении центров масс кластеров.

;[[глоссарий#Устойчивость|''Устойчивость'']]: Алгоритм является устойчивым к погрешностям во входных данных, так как при вычислении центров кластеров расстояния между объектами усредняются, что приводит к уменьшению ошибки. Алгоритм также является устойчивым к погрешностям, допускаемых при вычислениях, так как операция сложения на каждой новой итерации выполняется над входными данными.

;Сбалансированность: Множество входных векторов можно равномерно разделить между параллельными вычислителями. Центры всех кластеров можно распространить на все вычислители (так как их заведомо меньше, чем число входных векторов). В таком случае на каждой итерации определение для каждого объекта ближайшего кластера представляет собой вычисление расстояния от каждого входного вектора, находящегося на вычислителе, до каждого кластера, и является сбалансированной операцией. После данного этапа происходит пересчёт центров кластеров. Данная операция является несбалансированной в случаях, когда число объектов в одном из кластеров значительно больше числа объектов в других кластерах, из-за чего один кластер занимает большое число вычислителей, а остальные занимают по одному или несколько вычислителей. В таком случае для данного кластера потребуется вычислить центр [[Нахождение_частных_сумм_элементов_массива_сдваиванием | алгоритмом нахождения частичной суммы элементов массива путем сдваивания]]. Данная операция представляет несбалансированность порядка <math>O(log (k*n))</math>. После данного шага происходит сбалансированная операция рассылки центров кластеров на все вычислители.В идеальном случае параллелизации алгоритм не является сбалансированным, однако в реальных задачах, когда <math>n >> p</math>, где <math>p</math> - количество вычислителей, эта несбалансированность сглаживается наличием объектов из каждого кластера на каждом вычислителе

;Соотношение последовательной и параллельной сложности: <math>{O(n*d*k*i) \over O(log(n*d*k)*i)} \thicksim O \bigg( {n*d*k \over log(n*d*k)} \bigg)</math>

;[[глоссарий#Вычислительная мощность|''Вычислительная мощность'']]: Последовательный алгоритм: <math>{O(n*d*k*i) \over n*d+n+1} \thicksim {O(d*k*i) \over d+1} \thicksim O(k*i)</math>, где <math>n</math> - число входных векторов, <math>d</math> - размерность векторов, <math>k</math> - число кластеров, <math>i</math> - число итераций, требуемое для сходимостиПараллельный алгоритм: <math>O(log(n*d*k)*i) \over n*d+n+1</math>

;[[глоссарий#Детерминированность|''Детерминированность'']]: Алгоритм является недетерминированным, так как результат зависит от выбора исходных центров кластеров, а их оптимальный выбор неизвестен.

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
==== Локальность реализации алгоритма ====
===== Структура обращений в память и качественная оценка локальности =====
===== Количественная оценка локальности =====
=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===
Исследование проводилось на суперкомпьютере "Ломоносов" [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского Государственного Университета имени М.В. Ломоносова]

Набор данных для тестирования состоял из 946000 векторов размерности 2 (координаты на сфере)
Набор и границы значений изменяемых параметров запуска реализации алгоритма:

* число процессов (виртуальных ядер) [8 : 512];
* число кластеров [128 : 384].
В результате проведённых экспериментов был получен следующий диапазон эффективности реализации алгоритма:

* минимальная эффективность реализации <math>2,47%</math> достигается при делении исходных данных на 128 кластеров с использованием 512 процессов;
* максимальная эффективность реализации <math>7,13%</math> достигается при делении исходных данных на 352 кластера с использованием 8 процессов.
На рисунках 5 и 6 соответственно представлены графики зависимости производительности и эффективности параллельной реализации k means от числа кластеров и числа процессов.
[[file:kmeans_performance.jpg|thumb|center|720px|Рисунок 5. График зависимости производительности параллельной реализации алгоритма от числа кластеров и числа процессов. ]]
По рис. 5 можно отметить практически полное отсутствие роста производительности с увеличением числа процессов от 256 до 512 при минимальном размере задачи. Это связано с быстрым ростом накладных расходов по отношению к крайне низкому объёму вычислений. При росте размера задачи данный эффект пропадает, и при одновременном пропорциональном увеличении числа кластеров и числа процессов рост производительности становится близким к линейному.
[[file:kmeans_efficiency.jpg|thumb|center|720px|Рисунок 6. График зависимости эффективности параллельной реализации алгоритма от числа кластеров и числа процессов. ]]
Исследовалась [https://github.com/like-a-bauss/kmeans параллельная реализация алгоритма k means].
Были получены следующие оценки масштабируемости реализации алгоритма k means:
*По числу процессов: <math>-0.02209</math>. Следовательно, с ростом числа процессов эффективность уменьшается. На рис. 6 можно наблюдать плавное и равномерное снижение производительности по мере увеличения числа процессов при неизменном числе кластеров, что свидетельствует об относительно невысоком росте накладных расходов на передачу данных между процессами и преобладании объёма вычислений над объёмом пересылок данных по сети.
*По размеру задачи: <math>0.01252</math>. Следовательно, с ростом размера задачи (числа кластеров) эффективность увеличивается. При этом объём пересылок данных по сети пропорционален <math>(n + k) * p</math> (где <math>k</math> - число кластеров, <math>n</math> - число входных векторов, <math>p</math> - число процессов) таким образом, поскольку <math>k << n</math>, рост накладных расходов с ростом числа кластеров при неизменном числе процессов и входных векторов представляет собой незначительную величину.
*Общая оценка: <math>-0.00081</math>. Таким образом, с ростом и размера задачи, и числа процессов эффективность уменьшается. Это связано с тем, что отношение объёма вычислений к объёму передаваемых данных изменяется пропорционально <math>{n * k \over (n + k) * p} \thicksim {k \over p}</math>, что преставляет собой невысокий коэффициент, но при этом позволяет параллельной реализации не деградировать до нулевой эффективности при значительном увеличении числа процессов.

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

Существуют следующие Open Source реализации алгоритма:
* [http://elki.dbs.ifi.lmu.de/ ELKI] - содержит реализацию алгоритма k-means на языке Java (в том числе реализацию улучшенного алгоритма k-means++)
* [http://www.cs.waikato.ac.nz/~ml/weka/ Weka] - содержит реализацию k-means на языке Java
* [http://mahout.apache.org/ Apache Mahout] - содержит реализацию k-means в парадигме MapReduce
* [https://spark.apache.org/ Spark Mllib] - содержит распределенную реализацию k-means
* [http://accord-framework.net/ Accord.NET] - содержит реализацию k-means на C# (в том числе реализацию улучшенного алгоритма k-means++)
* [https://github.com/mlpack/mlpack MLPACK] - содержит реализацию k-means на языке C++
* [http://opencv.org/ OpenCV] - содержит реализацию k-means на C++. А также есть обертки для языков Python и Java
* [https://www.scipy.org/ SciPy] - содержит реализацию k-means на языке Python
* [http://scikit-learn.org/ Scikit-learn] - содержит реализацию k-means на языке Python
* [http://julialang.org/ Julia] - содержит реализацию алгоритма k-means на языке Julia
* [https://www.gnu.org/software/octave/ Octave] - содержит реализацию k-means на языке Octave
* [https://www.r-project.org/ R] - содержит реализацию k-means на языке R
* [http://torch.ch/ Torch] - содержит реализацию k-means на языке Lua

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

Участник:Sarseev/Алгоритм кластеризации, основанный на минимальном покрывающем дереве

2016-11-29T08:23:50Z

Zhum:

'''Автор''': Арсеев С. П., группа 620

== Свойства и структура алгоритма ==
=== Общее описание алгоритма ===
Данный алгоритм нацелен на решение задачи кластеризации, то есть, разделения множества объектов на группы, называемые кластерами, так, чтобы внутри одного кластера оказались наиболее похожие (по некоторой метрике) друг на друга объекты, а объекты из разных кластеров как можно сильнее отличались друг от друга.
Сам алгоритм состоит из следующих шагов:
# Сведение набора объектов к графу. Объекты становятся вершинами графа, и каждые две вершины соединяются ребром, длина которого равняется расстоянию между этими объектами по некоторой метрике. Выбор метрики зависит от предметной области и желаемых свойств алгоритма. Например, метрикой может служить евклидово расстояние.
# Построение минимального покрывающего (остовного) дерева в этом графе. Более подробно этот шаг описан в [[Построение_минимального_остовного_дерева_(MST)|соответствующей статье]].
# Кластеризация путём удаления некоторого количества рёбер в этом дереве. В случае, если заранее известно количество кластеров <math>k</math>, достаточно удалить <math>k-1</math> ребро с наибольшей длиной, чтобы получить <math>k</math> связных компонент, которые объявляются кластерами. Если же количество кластеров заранее не известно, удаляются рёбра с длиной больше некоторого порога, задаваемого как параметр алгоритма. Возможны и более сложные стратегии выбора рёбер для отсечения.
=== Математическое описание алгоритма ===
На вход алгоритму подаётся <math>n</math> объектов <math>a</math>, которые нужно кластеризовать. Каждый такой объект можно рассматривать как вектор или элемент некоторого метрического пространства. На пространстве, которому принадлежат <math>a</math>, задана метрика <math>d_{ij}=d(a_i,a_j)</math>. 
Первый шаг алгоритма строит граф <math>G=(V,E)</math>, где <math>V</math> - множество вершин графа <math>(|V|=n)</math>, а <math>E</math> - множество его рёбер <math>(|E| = \frac{n*(n-1)}{2})</math>. 
На втором этапе строится минимальное покрывающее дерево <math>MST(G)</math>. После удаления рёбер дерево распадается на поддеревья <math>MST_i</math>. Вершины, входящие в <math>i</math>-е поддерево, объявляются принадлежащими кластеру с номером <math>i</math>.
=== Вычислительное ядро алгоритма ===
Алгоритм состоит из трёх этапов:
# Преобразование исходных данных. Сложность <math>O(n^2)</math>.
# Поиск минимального покрывающего дерева. Последовательная сложность всех трёх основных алгоритмов ([[Алгоритм_Борувки|Борувки]], [[Алгоритм_Крускала|Крускала]] и [[Алгоритм_Прима|Прима]]) <math>O(|E|*log(|E|)) = O(n^2*log(n^2))</math>.
# Разбиение на кластеры. Вычислительная сложность <math>O(n)</math> для простых стратегий разбиения.
Таким образом, вычислительным ядром алгоритма является алгоритм построения минимального покрывающего дерева, поскольку он имеет наибольшую сложность. Стратегии распараллеливания алгоритма основаны на распараллеливании алгоритма построения минимального покрывающего дерева.
=== Макроструктура алгоритма ===
В состав алгоритма входит алгоритм [[Построение_минимального_остовного_дерева_(MST)|построения минимального покрывающего дерева]], являющийся его вычислительным ядром. Также в отдельную часть можно выделить алгоритм разбиения получившегося покрывающего дерева на кластеры.
=== Схема реализации последовательного алгоритма ===
Описание алгоритма на псевдокоде:
<source lang=cpp>
MST_Cluster(object[n] objects){
g = Pairs(objects, metric);
mst = Create_MST(graph);
parts = Split_MST(mst);
for i in range(parts){
clusters[i] = parts[i].vertices;
}
return clusters
}

</source>
=== Последовательная сложность алгоритма ===
Последовательная сложность алгоритма определяется самой сложной его частью (см. пункт 1.3) и равна <math>O(n^2*log(n^2))</math>.
=== Информационный граф ===
[[Файл:MST_cluster.png|thumb|center|1043px|Информационный граф алгоритма. Показана последовательная реализация (большой прямоугольник) и схема распараллеливания алгоритма построения минимального покрывающего дерева.]]
=== Ресурс параллелизма алгоритма ===
Ресурс параллелизма алгоритма основан на свойстве ассоциативности рёбер: 
Пусть <math>MSF(E)</math> – минимальный остовный лес (множество покрывающих деревьев) графа с рёбрами <math>E</math>. Тогда
:<math>
MSF(E_1 \cup E_2 \cup \dots \cup E_k) = MSF(MSF(E_1) \cup MSF(E_2) \cup \dots \cup MSF(E_k)).
</math>

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

Сложность параллельного алгоритма зависит от соотношения объёма входных данных и числа процессов. Существуют распределённые алгоритмы построения минимального покрывающего дерева, имеющие асимптотическую сложность <math>O(n*log(n))</math>. Эта же оценка будет выполняться и для всего алгоритма кластеризации.

=== Входные и выходные данные алгоритма ===
На вход алгоритму подаются объекты <math>(o_1, o_2, ..., o_n)</math>. 
Выходом алгоритма является множество непересекающихся кластеров: <math>C=(C_1, C_2, ..., C_k); C_i = (o_{i,1}, o_{i,2}, ..., o_{i, n_i}); o(i, l) \ne o(j, m); i \ne j; \forall l, m; \sum{n_i} = n </math>.
=== Свойства алгоритма ===
Важным свойством алгоритма является то, что при его распараллеливании по описанной выше стратегии важно правильно выбирать количество процессов. При увеличении количества процессов возрастают затраты на фазу слияния деревьев, полученных каждым процессом: растёт число этапов, в которые производится слияние, а следовательно, возрастают затраты на коммуникацию между процессами, и распределение нагрузки становится более неравномерным из-за того, что часть процессов должна проделать значительно большее количество работы по слиянию деревьев. 
Вычислительная мощность алгоритма имеет порядок <math>O(n*log(n^2))</math>. 
Ещё одним важным свойством алгоритма является его детерминированность в том случае, если для данного набора векторов существует единственное минимальное покрывающее дерево: при использовании детерминированной стратегии разбиения его на поддеревья алгоритм получает единственный результат для каждого набора данных. Однако, время работы может отличаться в зависимости от начального распределения рёбер по процессам.
== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===
[[Файл:MST_cluster_time.png|thumb|center|600px|Время работы алгоритма в зависимости от числа процессов и объёма входных данных.]]
На графике на логарифмической шкале показана зависимость времени работы алгоритма от числа процессов. Приведены измерения для восьми наборов данных, различающихся количеством входных векторов: от 1024 до 131072 элементов. Использовалась собственная реализация алгоритма, основанная на [https://github.com/gpiskas/MinSpanTree_Kruskal_MPI_OpenMP сторонней реализации] алгоритма построения минимального покрывающего дерева (без OpenMP-части для более точного измерения масштабируемости описанной выше архитектуры). Изменения относительно приведённой реализации в основном коснулись генерации входных данных для алгоритма построения остовного дерева: в качестве функции расстояния между элементами при генерации графа бралось случайное число от 0 до 1. Изменения времени работы алгоритма при разных запусках (и, соответственно, с другим набором случайных чисел) незначительны. 
Запуск проводился на аппаратной платформе [http://hpc.cmc.msu.ru/bgp IBM BlueGene/P]. Для каждого размера входных данных были проведены четыре теста: на 128, 256, 512 и 1024 вычислительных узлах соответственно. При дальнейшем увеличении объёма данных время выполнения программы превысило доступный предел (15 минут для 128 узлов). 
Построение отдельного графика эффективности распараллеливания затруднено, т.к. на больших объёмах данных последовательная реализация будет вычисляться слишком долго. Как видно из графика, эффективность распараллеливания падает с увеличением числа вычислительных узлов. Это объясняется возрастающими затратами на коммуникацию и неравномерной загрузкой процессоров на фазе слияния. 

=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===
Основным вычислительным ядром алгоритма является алгоритм построения минимального покрывающего (остовного) дерева, применяющийся для многих задач, и многие библиотеки ограничиваются его реализацией, без реализации основанного на нём алгоритма кластеризации. Примеры реализаций алгоритмов построения MST:
* С++: [http://www.boost.org/doc/libs/1_62_0/libs/graph/doc/ Boost graph library] (алгоритмы Борувки и Крускала)
* C++, MPI: [http://www.boost.org/doc/libs/1_62_0/libs/graph_parallel/doc/html/index.html Parallel boost graph library] (алгоритм Борувки)
* Java: [http://jgrapht.org/ JGraphT] (алгоритмы Крускала и Прима)
* Python: [http://docs.scipy.org/doc/scipy-0.15.1/reference/index.html SciPy]
== Литература ==
# Нейский И.М. Классификация и сравнение методов кластеризации 
# C. Kingsford. Minimum Spanning Trees & Clustering ([https://www.cs.umd.edu/class/fall2009/cmsc451/lectures/Lec07a-mst.pdf])
# Y. Zhou et al. Clustering with Minimum Spanning Trees

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

2016-11-29T08:23:37Z

Zhum:

п 2.4

* нет окончательного текста программы
* "Построение отдельного графика эффективности распараллеливания затруднено, т.к. на больших объёмах данных последовательная реализация будет вычисляться слишком долго." Разве это не важное свойство алгоритма?? Можно построить графики эффективности только параллельной части и всей программы целиком - прекрасная иллюстрация свойств алгоритма.

[[Участник:Zhum|Zhum]] ([[Обсуждение участника:Zhum|обсуждение]]) 11:23, 29 ноября 2016 (MSK)

Участник:Guryanovak/Алгоритм кластеризации, основанный на минимальном остовном дереве

2016-11-29T08:19:29Z

Zhum:

{{Assignment|Zhum}}
Авторы описания: [[Участник:guryanovak|Гурьянов Алексей Константинович]], [[Участник:Валерия Кибитова|Кибитова Валерия Николаевна]]

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

{{algorithm
| name = Алгоритм кластеризации, основанный на минимальном остовном дереве
| serial_complexity = <math>O(N^2 \log_2 N)</math>
| input_data = <math> O(Nm) </math>
| output_data = <math> O(N) </math>
}}

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

== Общее описание алгоритма ==
Данный алгоритм решает задачу кластеризации. Кластеризация – это задача разбиения множества объектов на не пересекающиеся подмножества, называемые кластерами таким образом, что объекты в одном кластере были более похожи (в каком-либо смысле) друг на друга, а объекты в разных кластерах существенно отличались.

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

Проблема нахождения минимального остовного дерева, а также ее решение было предложено Борувка в 1926 году. Идея использовать минимальное остовное дерево для кластеризации впервые была предложена Zahn в 1971<ref>Zahn C. T. Graph-theoretical methods for detecting and describing gestalt clusters //IEEE Transactions on computers. – 1971. – Т. 100. – №. 1. – С. 68-86.</ref>, в последующие годы данная идея развивалась такими учеными как: Asano, Bhattacharya, Keil, и Yao<ref>Asano T. et al. Clustering algorithms based on minimum and maximum spanning trees //Proceedings of the fourth annual symposium on Computational geometry. – ACM, 1988. – С. 252-257.</ref>, Avis<ref>Avis D. Diameter partitioning //Discrete & Computational Geometry. – 1986. – Т. 1. – №. 3. – С. 265-276.</ref>, Eldershaw и Hegland<ref>Eldershaw C., Hegland M. Cluster analysis using triangulation //Computational Techniques and Applications. – 1997. – С. 201-208.</ref>, Paivinen и другими<ref>Grygorash O., Zhou Y., Jorgensen Z. Minimum spanning tree based clustering algorithms //2006 18th IEEE International Conference on Tools with Artificial Intelligence (ICTAI'06). – IEEE, 2006. – С. 73-81.</ref>.

Основная идея алгоритма состоит из следующих шагов:

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

2. Построение минимального остовного дерева.
Для этого можно использовать следующие алгоритмы:
*алгоритм Крускала;
*алгоритм Прима;
*алгоритм Борувки.

3. Выделение кластеров.
В минимальном остовном дереве, выбирается <math>k-1</math> ребро (где <math>k</math> – это заранее определенное число кластеров), имеющие наибольшой вес. Выбранные ребра удаляются. Оставшиеся k компонент связности считаются кластерами.

В данной статье алгоритм будет описываться с использованием алгоритма Борувки. Подробное описание которого можно найти пройдя по ссылке [[https://algowiki-project.org/ru/Алгоритм_Борувки Алгоритм Борувки]]

Общая идея его состоит в следующем:
#Изначально каждая вершина графа — тривиальное дерево, а ребра не принадлежат никакому дереву.
#Для каждого дерева найдем минимальное по весу инцидентное ему ребро. Добавим все такие ребра.
#Повторяем шаг 2 пока в графе не останется только одно дерево.

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

На вход алгоритму подается набор <math>N</math> векторов размерности <math>m</math> : <math>(a_{i,1}, a_{i,2}, ..., a_{i,m})</math>, где <math> a_j \in \mathbb {R} \quad \forall j \in [1,m], i \in [1..N] </math> и количество кластеров <math>K</math>, на которые необходимо разбить множество точек.

На выход алгоритм должен вывести <math>N</math> чисел от <math>1</math> до <math>K</math>, показывающих принадлежность входных векторов кластерам.

=== Основные обозначения ===

* <math>E</math> - множество рёбер.
* <math>V</math> - множество вершин.
* <math>G = (V,E) </math> - неориентированный граф, заданный множеством вершин <math>V</math> и множеством рёбер <math>E</math>
* <math>MST(G)</math> (Minimum Spanning Tree) - минимальное остовное дерево графа <math></math>. Остовное дерево — ациклический связный подграф данного связного неориентированного графа, в который входят все его вершины. Минимальное остовное дерево в связанном взвешенном неориентированном графе — это остовное дерево этого графа, имеющее минимальный возможный вес, где под весом дерева понимается сумма весов входящих в него рёбер.

=== Функция веса ===

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

В данной статье будет рассматриваться евклидова метрика:
* <math> | x , y | = \sqrt{\sum_i^m (x_i - y_i)^2} </math>

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

Работу алгоритма можно разделить на три блока:
*1: Вычисление расстояний между вершинами и заполнение данных о компонентах связности
*2: Построение минимального основного дерева
*3: Разделение на K кластеров

Из них основное время работы алгоритма занимают блоки 1 и 2.

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

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

Для описания алгоритма вводятся следующие макрооперации:
*1: getDistance – находит расстояние между двумя вершинами графа как расстояние между соответствующими им точками пространства. (Сложность – <math>O(m)</math>)
*2: initializeComponents – инициализирует состояние класса Components информацией о вершинах и ребрах. В каждую исходную компоненту связности входит одна вершина. (Сложность – <math>O(N^2)</math>)
*3: findMinimalOutgoingEdge – находит ребро c наименьшей длиной, исходящее из заданной компоненты связности. (Cложность – <math>O(N)</math>)
*4: findComp – возвращает индекс компоненты связности в которой находится вершина (Cложность – <math>O(1)</math>)
*5: connectComponentsWithEdge – соединяет две компоненты связности, связанные поданным на вход ребром. Объединение компонент включает в себя замену ребер инцидентности новой компоненты на минимальные ребра из пары объединяемых компонент. (Сложность – <math>O(N)</math>)

Макрооперации 2-5 относятся к последовательной реализации [[Алгоритм Борувки|алгоритма Борувки]], который был выбран как основа вычислительного ядра алгоритма.

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

Схема работы алгоритма была создана с учетом последующей параллельной реализации,<ref>Chung S., Condon A. Parallel implementation of Bouvka's minimum spanning tree algorithm //Parallel Processing Symposium, 1996., Proceedings of IPPS'96, The 10th International. – IEEE, 1996. – С. 302-308.</ref>

<source lang="cpp">
int N; // Размер входных данных
int number_of_clusters; // Число кластеров
int size = N*N; // Размер матрицы инцидентности
Node nodes[N]; // Вершины(точки), заданные начальными условиями
Edge edges[size]; // Все расстояния между вершинами
vector<Edge> tree; // Рёбра минимального остовного дерева
Components comps; // Структура компонент связности
read_data(&nodes, file_name); // Считывание начальных данных

//----------------Вычисление расстояний между вершинами----------------//
for(int i = 0; i < N-1; i++) {
for(int j = i+1; j < N; j++) {
double distance = getDistance(node[i], node[j]); // Вычисление расстояний между вершинами
edges[i*N + j] = Edge(i,j,distance); // Запись значения расстояния в массив
edges[j*N + i] = Edge(i,j,distance); // Запись значения расстояния в массив
}
}

//----------------Заполнение данных о компонентах связности--------------//
initializeComponents(&comps, nodes, edges);

//----------------Построение минимального основного дерева--------------//
while(comps.size > 1) {
vector<edges> mstedges;
for component in comps {
edge e = findMinimalOutgoingEdge(component, comps, edges) // Нахождение минимального ребра инцидентного данной компоненте
mstedges.add(e)
}
for mstedge in mstedges {
if (findComp(comps, mstedge.first) != findComp(comps, mstedge.second)) {
connectComponentsWithEdge(comps, mstedge) // Объединение двух компонент
tree.add(mstedge) // Добавление ребра в минимальное основное дерево
}
}
}

//-----------------------Разделение на K кластеров--------------------------//
sort(tree)
for(int i = tree.size() - 1; i > tree.size() - 1 - number_of_clusters; i--) {
remove_edge(tree, i); // Удаление самых длинных рёбер из MST - формирование кластеров
}
write_data(tree); // Запись выходных данных
</source>

== Последовательная сложность алгоритма ==
Среди выделенных в описании частей алгоритма, самую большую сложность для оценивания временной сложности вызывает часть 3, являющаяся реализацией алгоритма Борувки. Однако если заметить, что после выполнения каждого тела внешнего цикла количество компонент связности будет уменьшаться как минимум вдвое (так как одно ребро в списке ребер минимального основного дерева может повториться максимум двое), то можно сделать вывод, что сложность в худшем случае этого блока алгоритма является <math> O (N^2 \log_2 N) </math>.

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

<math> TC(N, m) = O(N^2m) + O(N^2) + O(N^2 \log_2 N) + O(N \log_2 N) = O(N^2 (m + \log_2 N)) </math>

Если посчитать размерность пространства входных точек за константу при расчете сложности, то временная сложность выразится как

<math> TC(N, m) = O(N^2 \log_2 N) </math>

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

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

[[Файл:InformationGraph-2-8.png|frame|center|alt=Алгоритм| Информационный граф параллельного алгоритма кластеризации на основе алгоритма Борувки]]

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

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

Основная особенность алгоритма построения минимального основного дерева Борувки состоит в том, что основной блок этого алгоритма, нахождения минимального ребра, инцидентного заданной вершине, можно проводить независимо. Это позволяет провести вычисления в ярусе, ответственном за поиск кратчайших ребер за <math>O(1)</math> времени при наличии как минимум <math>N^3</math> процессоров. Процесс обновления информации о компонентах связности, который заключается в обновлении индексов кластеров вершин и в обновлении расстояний между кластерами, можно представить в виде независимой последовательности операций взятия минимума и операций присваивания в количестве <math>O(N)</math> штук (количество компонент связности), что позволит выполнить ярус, ответственный за обновление структуры компонент связности за <math>O(1)</math> при наличие как минимум <math>2N</math> процессоров. Это значит, что каждый ярус будет выполняться за <math> O(1) </math> времени, и аналогично последовательному алгоритму Борувки, после выполнения 2 ярусов количество компонент связности уменьшится минимум вдвое, что гарантирует то, что за время выполнения алгоритма повторится не более чем <math> 4 * \log_2 N </math> ярусов. Учитывая ярусы, посвященные считыванию ввода, вычислению расстояний между точками пространства, удалению <math>K-1</math> ребер из минимального опорного дерева и выводу ответа, итоговую параллельная сложность алгоритма можно оценить как <math> 2 * \log_2 N + 5</math>.

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

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

=== Входные данные алгоритма ===
На вход алгоритму подается набор <math>N</math> векторов размерности <math>m</math> : <math>(a_{i,1}, a_{i,2}, ..., a_{i,m})</math>, где <math> a_j \in \mathbb {R} \quad \forall j \in [1,m], i \in [1..N] </math> и количество кластеров <math>K</math>, на которые необходимо разбить множество точек. Общий объем входных данных можно оценить как <math>O(Nm)</math>.

Если оценивать размерность пространства входных точек константой, то объем входных данных можно оценить как <math>O(N)</math>.

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

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

Соотношение последовательной и параллельной сложности алгоритма равно <math> \frac{N^2 \log_2 N} {\log_2 N} = N^2 </math>.

Вычислительную мощность алгоритма можно оценить как <math> \frac {N^2 \log_2 N} {N} = N \log_2 N</math>.

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

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

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

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

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

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

== Масштабируемость алгоритма и его реализации ==
Авторами данной статьи было проведено исследование масштабируемости параллельной реализации алгоритма кластеризации, основанном на минимальном остовном дереве. Исследование алгоритма проводилось на суперкомпьютере "Ломоносов" [http://parallel.ru/cluster суперкомпьютерного комплекса Московского университета]. Параллельная реализация была написана с помощью OpenMP. Распараллеливание проводилось по числу объектов кластеризации, поэтому исследование масштабируемости проводилось для числа объектов кластеризации. Алгоритм исследовался на наборе данных, который был сгенерирован при помощи функции [http://scikit-learn.org/stable/modules/generated/sklearn.datasets.make_blobs.html make_blobs (sklearn)] (количество признаков – 2, количество кластеров – 2).

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

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

На графиках, представленных ниже, отображена [[Глоссарий#Производительность|производительность]] и [[Глоссарий#Эффективность распараллеливания|эффективность распараллеливания]] алгоритма кластеризации, основанного на минимальном остовном дереве, в зависимости от изменяемых параметров запуска.
[[File:Execution_GK_MST.png|800px|thumb|center|Рис.1. Изменение производительности в зависимости от числа процессов и числа входных объектов]]
[[File:Efficiency_MST_GK.png|800px|thumb|center|Рис.2. Изменение эффективности распараллеливания в зависимости от числа процессов и числа входных объектов]]

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

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

'''По числу процессов''' - При увеличении числа процессов происходит снижение эффективности на всей области рассматриваемых значений параметров, при этом скорость уменьшения эффективности (производная функции эффективности от количества процессов) убывает на всей области рассматриваемых значений. Это объясняется тем соображением, что на основании формулы [[https://ru.wikipedia.org/wiki/Закон_Амдала закона Амдала]] с <math>\alpha</math> последовательной долей времени исполнения и с <math>p</math> процессами эффективность распараллеливания можно выразить как <math>E = S / p = \frac{1}{p\alpha + 1 - \alpha}</math>, что есть гипербола от количества процессов.

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

[https://bitbucket.org/GuryanovKibitova/mstclusterization/src/ccaffad7780e3aee9645845539e6e1a311295208?at=master Параллельная реализация на языке C++ (+OpenMP)]

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

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

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

Существующих реализаций алгоритма кластеризации в настоящий момент немного. Ниже приводится список некоторых из них:
*[https://github.com/jakevdp/mst_clustering MST Clustering Python]
Однако существует множество реализаций алгоритма поиска минимального остовного дерева, на основе которых можно реализовать алгоритм кластеризации.
*[https://github.com/umarali/boruvka-mst-parallel Parallel Implementation of Borůvka's MST Algorithm ]
*[http://www.mlpack.org/docs/mlpack-2.0.2/doxygen.php?doc=namespacemlpack_1_1emst.html С++ mlpack MST Algorithm ]
*[https://github.com/nastra/algorithms-java Java Graph Algorithms]
*[http://jgrapht.org/javadoc/org/jgrapht/alg/KruskalMinimumSpanningTree.html Kruskal Java MST Algorithm ]
*[http://jgrapht.org/javadoc/org/jgrapht/alg/PrimMinimumSpanningTree.html Prim Java MST Algorithm ]
*[https://github.com/dineshappavoo/GraphMinimumSpanningTree Java Graph Minimum Spanning Tree ]
*[https://pypi.python.org/pypi/PyAlgDat Python PyAlgDat ]
*[https://networkx.github.io/documentation/networkx-1.10/reference/algorithms.mst.html Python NetworkX Minimum Spanning Tree]
*[http://www.boost.org/doc/libs/1_53_0/libs/graph_parallel/doc/html/dehne_gotz_min_spanning_tree.html C++ Boost Minimum Spanning Tree]

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

<references \>

Участник:Parkhomenko/Алгоритм k средних

2016-11-25T13:27:59Z

Zhum:

{{algorithm
| name = Алгоритм k средних
| serial_complexity = <math>O(tnkd)</math>
| input_data = <math>nd</math>
| output_data = <math>n</math>
| pf_height = <math>O(t * \log kdn)</math>
| pf_width = <math>O(kdn)</math>
}}

Основные авторы описания: [[Участник:Parkhomenko|П.А.Пархоменко]] ([[#Общее описание алгоритма|1.1]], [[#Вычислительное ядро алгоритма|1.3]], [[#Последовательная сложность алгоритма|1.6]], [[#Ресурс параллелизма алгоритма|1.8]], [[#Входные и выходные данные алгоритма|1.9]], [[#Свойства алгоритма|1.10]], [[#Масштабируемость алгоритма и его реализации|2.4]]), [[Участник:Ivan.mashonskiy|И.Д.Машонский]] ([[#Математическое описание алгоритма|1.2]], [[#Макроструктура алгоритма|1.4]], [[#Схема реализации последовательного алгоритма|1.5]], [[#Информационный граф|1.7]], [[#Ресурс параллелизма алгоритма|1.8]], [[#Свойства алгоритма|1.10]], [[#Существующие реализации алгоритма|2.7]])
== Свойства и структура алгоритмов ==

=== Общее описание алгоритма ===
Алгоритм k средних (англ. k-means) - один из алгоритмов машинного обучения, решающий задачу кластеризации. Он был изобретен в середине 1950-х математиком Гуго Штейнгаузом<ref>Steinhaus H. (1956). Sur la division des corps materiels en parties. Bull. Acad. Polon. Sci., C1. III vol IV: 801—804.</ref> и Стюартом Ллойдом<ref>Lloyd S. (1957). Least square quantization in PCM’s. Bell Telephone Laboratories Paper.</ref>. Алгоритм стал особо популярным после публикации Маккуина<ref>MacQueen J. (1967). Some methods for classification and analysis of multivariate observations. In Proc. 5th Berkeley Symp. on Math. Statistics and Probability, pages 281—297.</ref>, в которой впервые был использован термин “k-means”.

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

K-means является итерационным алгоритмом, разновидностью EM-алгоритма. Основная идея работы алгоритма заключается в проведении некоторого количества итераций, на каждой из которых происходит пересчет центра масс для каждого кластера, полученного на предыдущей итерации. После этого векторы перераспределяются по кластерам: вектор относится к тому кластеру, расстояние до центра масс которого минимально. Алгоритм завершает работу в том случае, если на очередной итерации центры масс кластеров не изменились.

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

Исходные данные: множество d-мерных векторов (наблюдений) <math>X</math> = <math>\{x_1, x_2, ..., x_n\}</math>, число кластеров <math>k \in \mathbb{N}</math>

В результате работы алгоритма исходное множество векторов <math>X</math> разбивается на <math>k</math> непересекающихся множеств (кластеров) <math>S_1, S_2, ..., S_k</math>, таких что <math>X = {\bigcup \limits _{i = 1}^k S_i} </math> и значение <math>\sum_{i=1}^{k} \sum_{\mathbf x \in S_i} \left\| \mathbf x - \mu_i \right\|^2 </math> — минимально для всех возможных наборов <math>S_1, S_2, ..., S_k</math>.
Под <math>\mu_i</math> здесь подразумевается центр масс векторов из множества <math>S_i</math>.

Первоначальные значения центров масс <math>\mu_1^{(1)}, ..., \mu_k^{(1)}</math> определяются в начале работы алгоритма случайным образом среди векторов множества <math>X</math>.

Алгоритм заключается в попеременном применении двух шагов <ref>MacKay, David (2003). "Chapter 20. An Example Inference Task: Clustering" (PDF). Information Theory, Inference and Learning Algorithms. Cambridge University Press. pp. 284–292.</ref>: '''распределения''' векторов по кластерам и '''обновления''' центров масс каждого кластера

'''Распределение векторов по кластерам''': на данном шаге каждый вектор распределяется в один из кластеров <math>S_i^{(t)}</math>:
::<math>S_i^{(t)} = \big \{ x_p : \big \| x_p - \mu^{(t)}_i \big \|^2 \le \big \| x_p - \mu^{(t)}_j \big \|^2 \ \forall j, 1 \le j \le k \big\},</math>
'''Обновление центров масс''': на данном шаге вычисляются новые центры масс для кластеров, полученных на предыдущем шаге.
::<math>\mu^{(t+1)}_i = \frac{1}{|S^{(t)}_i|} \sum_{x_j \in S^{(t)}_i} x_j </math>

Алгоритм завершается, когда на очередном шаге не происходит изменения центров масс кластеров.

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

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

Для соотнесения вектора к одному из кластеров, необходимо для каждого из N вектора посчитать расстояние до центров масс всех K кластеров. Для нахождения расстояния между двумя d-мерными векторами p и q используется Евклидова метрика: <math>\sqrt{\sum_{k=1}^d (p_k-q_k)^2}</math>

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

Инициализация центров масс кластеров

В начале алгоритма осуществляется инициализация центров масс <math>\mu_1^{(1)}, ..., \mu_k^{(1)}</math>, которая может быть реализована двумя возможными способами <ref>Hamerly, G.; Elkan, C. (2002). "Alternatives to the k-means algorithm that find better clusterings" (PDF). Proceedings of the eleventh international conference on Information and knowledge management (CIKM).</ref>:
* случайный выбор центров масс среди исходных наблюдений <math>x_1, x_2, ..., x_n</math>;
* все наблюдения случайным образом распределяются по кластерам <math>S_1, S_2, ..., S_k</math>, а затем для каждого кластера выполняется операция обновления центра масс.

Распределение векторов по кластерам

На шаге распределения векторов по кластерам производится операция нахождения квадратов расстояний между векторами кластера и центром масс кластера:
::<math>\rho = \big \| x_p - \mu^{(t)}_i \big \|^2</math>

Обновление центров масс кластеров

На шаге обновления центров масс производится операция суммирования векторов кластера:
::<math>\mu^{(t+1)}_i = \frac{1}{|S^{(t)}_i|} \sum_{x_j \in S^{(t)}_i} x_j </math>

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

Последовательность исполнения метода следующая:
# Инициализируются центры масс <math>\mu_1^{(1)}, ..., \mu_k^{(1)}</math>
# <math>t := 1</math>
# Для каждого вектора <math>x_i, i = 1, 2, ..., n</math> вычисляется <math>m = \underset{j \in \{1, 2, ..., k\}} {\operatorname{arg\,min}} \big \| x_i - \mu^{(t)}_j \big \|^2</math>, вектор <math>x_i</math> распределяется в кластер <math>S^{(t)}_m</math>
# Для каждого <math>j = 1, 2, ..., k</math> вычисляется <math>\mu^{(t+1)}_j = \frac{1}{|S^{(t)}_i|} \sum_{x_j \in S^{(t)}_i} x_j </math>
# Если <math>\mu^{(t)}_j = \mu^{(t+1)}_j, j = 1, 2, ..., k</math>, завершить выполнение алгоритма, иначе <math>t := t + 1</math>, переход на шаг 3.

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

Для вычисления центра массы кластера, содержащего <math>n_i</math> d-мерных векторов, необходимо:
* <math>n_i * (d - 1)</math> операций сложения
* <math>d</math> операций деления

Для определения центров масс всех k кластеров требуется:
* <math>n * (d - 1)</math> операций сложения
* <math>k * d</math> операций деления

Для определения расстояния между двумя d-мерными векторами, требуется:
* <math>d</math> операций вычитания
* <math>d</math> операций умножения
* <math>d - 1</math> операций сложения

Для определения кластера для n d-мерного векторов, необходимо:
* <math>n * k * d</math> операций вычитания
* <math>n * k * d</math> операций умножения
* <math>n * k * (d - 1)</math> операций сложения

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

Сложность всего алгоритма, состоящего из <math>t</math> итераций: <math>O(t * n * k * d)</math>

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

В данном разделе описывается информационный граф алгоритма k-средних при <math>n = 3, k = 2</math>

На рисунке 1 показана общая структура алгоритма: в качестве входных данных выступает матрица, строками которой являются входные векторы <math>x_1, x_2, x_3</math>, на выходе получается массив из <math>n</math> чисел, где элемент с номером <math>i = 1, 2, 3</math> обозначает номер кластера, которому принадлежит вектор <math>x_i</math>. На шаге <math>init</math> происходит инициализация значений центров масс кластеров, после этого осуществляется итеративное повторение этапов распределения векторов по кластерам (<math>as</math>) и обновления значений центров масс кластеров (<math>up</math>). Когда на очередном шаге обновления центров масс кластеров значения центров масс не изменяются, алгоритм завершает работу, и в качестве выходных данных выступают номера кластеров для каждого из входных векторов.
[[file:k_means_main.png|thumb|center|400px|Рисунок 1. Общая схема работы алгоритма k-средних]]

'''Распределение векторов по кластерам.''' На рисунке 2 изображен информационный граф для этапа распределения векторов по кластерам. В качестве входных данных выступают строки входной матрицы (входные векторы) <math>x_1, x_2, x_3</math> и текущие значения центров масс кластеров <math>\mu_1, \mu_2</math> (вычисленные на этапе инициализации или предшествующего этапа обновления центров масс кластеров). В качестве выходных данных выступают числа <math>m_1, m_2, m_3</math>, где <math>m_i, i = 1, 2, 3</math> - номер кластера, содержащего вектор <math>x_i</math>. Вершинами с пометкой <math>sub</math> обозначены операции векторной разности, вершинами <math>sn</math> - операция вычисления квадрата нормы вектора, вершинами <math>am</math> - операция <math>\underset{i \in \{1, 2\}} {\operatorname{arg\,min}} p_i</math>.
[[file:k_means_info_graph_as.png|thumb|center|400px|Рисунок 2. Граф алгоритма для этапа распределения векторов по кластерам]]
'''Обновление центров масс кластеров.''' На рисунке 3 представлен информационный граф для этапа обновления центров масс кластеров. В качестве входных данных выступают строки входной матрицы (входные векторы) <math>x_1, x_2, x_3</math> с соответствующими номерами кластеров <math>m_1, m_2, m_3</math>, содержащих эти векторы. В качестве выходных данных здесь выступают обновленные значения центров масс кластеров: <math>\mu_1, \mu_2</math>. Вершинами с пометками <math>s_i, i = 1, 2</math> обозначены операции суммирования векторов, принадлежащих кластеру <math>i</math>. Вершинами с пометками <math>cs_i, i = 1, 2</math> обозначены операции вычисления выражения <math>1 / |S_i|</math>, где за <math>S_i</math> обозначен кластер с номером <math>i</math>. Вершинами с пометкой <math>p</math> обозначена операция произведения.
[[file:k_means_info_graph_up.png|thumb|center|400px|Рисунок 3. Граф алгоритма для этапа обновления центров масс кластеров]]

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

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

В силу особенностей алгоритма k средних порядок выполнения основных этапов существенен, что не позволяет выполнять их параллельно. Таким образом, итоговая сложность параллельного алгоритма будет определяться, исходя из формулы <math>T = t * (T_{as} + T_{up})</math>, где <math>T_{as}</math> - параллельная сложность этапа распределения векторов по кластерам, <math>T_{up}</math> - параллельная сложность этапа обновления центров масс кластеров, <math>t</math> - общее число итераций алгоритма.

Параллельная сложность этапа распределения векторов по кластерам с учетом доступности неограниченного числа процессоров вычисляется следующим образом: так как вычисление значений <math>\big \| x_i - \mu^{(t)}_j \big \|^2</math> для каждой пары векторов <math>x_i, i = 1, 2, ..., n</math> и <math>\mu^{(t)}_j, j = 1, 2, ..., k</math> можно выполнять независимо и для вычисления этого выражения требуется <math>O(\log d)</math> операций в соответствии с [[Нахождение_частных_сумм_элементов_массива_сдваиванием | параллельной реализацией нахождения сумм элементов массива сдваиванием]]. Параллельная сложность реализации операции нахождения минимума из <math>k</math> элементов определяется как <math>O(\log k)</math>. Таким образом, сложность этапа распределения векторов по кластерам <math>O(\log kd)</math>.

Параллельная сложность этапа обновления центров масс кластеров вычисляется следующим образом: так как обновление значений каждого из центров масс кластеров можно выполнять независимо, параллельная сложность определяется сложностью обновления центра масс самого большого кластера. В худшем случае для нахождения значения выражения <math>\mu^{(t+1)}_j = \frac{1}{|S^{(t)}_i|} \sum_{x_j \in S^{(t)}_i} x_j </math> требуется <math>O(\log n)</math> операций.

С учетом вышесказанного, итоговая параллельная сложность алгоритма k средних определяется выражением <math>O(t * \log kdn)</math>.

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

'''Входные данные''':
* целое неотрицательное число <math>k</math> - количество кластеров;
* матрица координат векторов <math>A</math> размерностью <math>n * d</math>.

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

'''Выходные данные''':
* вектор длины <math>n</math> - для каждого вектора указан номер кластера.

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

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

Соотношение последовательной и параллельной сложности алгоритма равно <math>\frac{O(tnkd)}{O(t * \log kdn)}</math>.

Число операций алгоритма k средних оценивается как <math>O(tnkd)</math>, суммарный объем входных и выходных данных равен <math>n(d+1)</math>. Следовательно, вычислительная мощность алгоритма линейна по <math>k</math> и линейна по <math>t</math>.

Стоит отметить следующие ключевые особенности алгоритма k средних:
* Алгоритм прост в реализации и имеет высокую скорость работы по сравнению с другими алгоритмами кластеризации (при удачном выборе начальных значений центров масс кластеров)
* В качестве метрики используется евклидово расстояние, а в качестве меры разброса кластера используется дисперсия
* Количество кластеров k является входным параметром алгоритма, поэтому неправильный выбор этого параметра может негативно повлиять на качество кластеризации
* Сходимость алгоритма к локальному минимуму может породить некорректный конечный результат работы
* Алгоритм очень чувствителен к выбору начальных центров масс кластеров: классический вариант подразумевает случайный их выбор, что может являться источником погрешности. Из этого и предыдущего свойства следует то, что алгоритм не является устойчивым.

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

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

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

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

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

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

=== Масштабируемость алгоритма и его реализации ===
Исследование масштабируемости алгоритма k-means в зависимости от количества используемых процессов было проведено в статье Кумара<ref>Kumar, J., Mills, R. T., Hoffman, F. M., & Hargrove, W. W. (2011). Parallel k-means clustering for quantitative ecoregion delineation using large data sets. Procedia Computer Science, 4, 1602-1611.</ref>. Исследование происходило на суперкомпьютере Jaguar - Cray XT5<ref>https://www.top500.org/system/176029</ref>. На момент экспериментов данный суперкомпьютер имел следующую конфигурацию: 18,688 вычислительных узлов с двумя шестнадцатиядерными процессорами AMD Opteron 2435 (Istanbul) 2.6 GHz, 16 GB of DDR2-800 оперативной памяти, и SeaStar 2+ роутер. Всего он состоял из 224,256 вычислительных ядер, 300 TB памяти, и пиковой производительностью 2.3 petaflops.

Реализация алгоритма была выполнена на языке программирования C с использованием MPI.

Объем данных составлял 84 гигабайта, количество объектов (d-мерных векторов) n равнялось 1,024,767,667, размерность векторов d равнялась 22, количество кластеров k равнялось 1000.

На рисунке 4 показана зависимости времени работы алгоритма кластеризации k-means в зависимости от количества используемых процессоров. Можно отметить, что время, затраченное на чтение данных и запись результатов кластеризации, практически не изменяется с увеличением количества задействованных процессоров. Время же работы самого алгоритма кластеризации уменьшается с увеличением количества процессоров.
[[Файл:k-means-proc-scalability.png|thumb|center|700px|Рисунок 4. Зависимости времени работы алгоритма кластеризации k-means в зависимости от количества используемых процессоров.]]

Также было произведено самостоятельное исследование масштабируемости алгоритма. Исследование производилось на суперкомпьютере "Blue Gene/P"<ref>http://hpc.cmc.msu.ru/bgp</ref>.

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

* число процессоров [1, 2, 4, 8, 16, 32, 64, 128, 256, 512];
* количество объектов [5000, 10000, 25000, 50000].

Был использован набор данных ''Dataset for Sensorless Drive Diagnosis Data Set''<ref>PASCHKE, Fabian ; BAYER, Christian ; BATOR, Martyna ; MÃ–NKS, Uwe ; DICKS, Alexander ; ENGE-ROSENBLATT, Olaf ; LOHWEG, Volker: Sensorlose ZustandsÃ¼berwachung an Synchronmotoren, Bd. 46. In: HOFFMANN, Frank; HÃœLLERMEIER, Eyke (Hrsg.): Proceedings 23. Workshop Computational Intelligence. Karlsruhe : KIT Scientific Publishing, 2013 (Schriftenreihe des Instituts fÃ¼r Angewandte Informatik - Automatisierungstechnik am Karlsruher Institut fÃ¼r Technologie, 46), S. 211-225</ref> из репозитория ''Machine learning repository''<ref>https://archive.ics.uci.edu/ml/datasets/Dataset+for+Sensorless+Drive+Diagnosis</ref>.

Исследуемый набор данных содержит векторы, размерность которых равна 49. Компоненты векторов являются вещественными числами. Количество кластеров равно 11. Пропущенные значения отсутствуют.

Для исследования масштабируемости алгоритма была использована реализация на языке C с использованием MPI<ref>http://users.eecs.northwestern.edu/~wkliao/Kmeans/index.html</ref>. Код можно найти здесь: https://github.com/serban/kmeans.

На рисунке 5 показана зависимости времени работы алгоритма кластеризации k-means в зависимости от количества используемых процессоров. Можно видеть, что при увеличении количества процессоров в N раз, время работы алгоритма уменьшается примерно в N раз (при условии, что количество объектов остается неизменным). Также можно отметить, что при фиксированном количестве процессоров, зависимость времени работы алгоритма от количества объектов также близка к линейной.
[[Файл:Heatmap_kmeans.png|thumb|center|900px|Рисунок 5. Зависимости времени работы алгоритма кластеризации k-means в зависимости от количества используемых процессоров.]]

На рисунке 6 показана зависимости времени работы алгоритма кластеризации k-means в зависимости от количества используемых процессоров (при фиксированном количестве объектов, равном 50000). При визуализации была использована логарифмическая шкала. Можно отметить, что при заданном наборе данных можно наблюдать линейную зависимость времени работы алгоритма от количества используемых процессоров, что согласуется с теоретической оценкой сложности последовательной версии алгоритма.
[[Файл:50000kmeans.png|thumb|center|900px|Рисунок 6. Зависимости времени работы алгоритма кластеризации k-means в зависимости от количества используемых процессоров (количество объектов равно 50000).]]

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

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

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

Существуют следующие реализации алгоритма k-средних:
* [http://scikit-learn.org/ scikit-learn] библиотека машинного обучения для языка Python.
* [https://www.scipy.org/ SciPy] библиотека на языке Python, содержащая большое число реализаций различных алгоритмов, в том числе ''k''-средних.
* [http://elki.dbs.ifi.lmu.de ELKI] библиотека для анализа данных на языке программирования Java, содержит различные алгоритмы кластеризации, в том числе ''k''-средних.
* [http://mlpack.org MLPACK] библиотека машинного обучения для C++, содержит реализацию алгоритма ''k''-средних.
* [https://github.com/JuliaStats/Clustering.jl Julia k-means] реализация алгоритма ''k''-средних на языке программирования Julia.
* [http://opencv.org/ OpenCV] библиотека содержит реализацию ''k''-средних.
* [http://mahout.apache.org Apache Mahout] содержит реализацию алгоритма ''k''-средних на базе MapReduce.
* [http://www.cs.waikato.ac.nz/~ml/weka Weka] библиотека и инструмент для анализа данных на языке Java.
* [http://torch.ch/ Torch] библиотека машинного обучения на базе языка программирования Lua.
* [https://spark.apache.org/ Apache Spark MLlib] содержит распределенную реализацию алгоритма ''k''-средних.
* [http://www.accord-framework.net/ Accord.NET] содержит несколько различных реализаций ''k''-средних на языке C#.
* [https://www.r-bloggers.com/k-means-clustering-in-r/ R k-means] реализация ''k''-средних на языке R.

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

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

2016-11-25T13:27:48Z

Zhum:

п. 2.4

* "Для вычисления производительности в неё был вписан код на MPI, реализующий подсчёт числа операций с плавающей точкой" - вписан Вами? Тогда где эта реализация? Если нет, зачем это отдельно отмечать?
* К графикам нет внятных пояснений.

Исправления:
* Ссылка на окончательный текст программы была вписана еще в прошлый раз. Цитата: "Для вычисления производительности в неё был вписан код на MPI, реализующий подсчёт числа операций с плавающей точкой: [https://github.com/like-a-bauss/kmeans окончательный текст программы].". Выделила жирным ссылку, чтобы было видно.
* Добавлены пояснения.

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

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

2016-11-23T12:04:38Z

Zhum:

{{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 />

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

2016-11-23T12:01:02Z

Zhum:

{{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>



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

Участник:Parkhomenko/Алгоритм k средних

2016-11-23T11:58:21Z

Zhum:

Участник:Parkhomenko/Алгоритм k средних

2016-11-23T11:58:03Z

Zhum:

Участник:IanaV/Алгоритм k means

2016-11-23T11:53:17Z

Zhum:

{{level-a}}
Авторы страницы: [[Участник:IanaV|Валуйская Я.А.]], [[Участник:GlotovES|Глотов Е.С.]]

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

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

=== Общее описание алгоритма ===
Алгоритм k-means (k средних) - один из наиболее популярных алгоритмов кластеризации. Наиболее простой, но в то же время достаточно неточный метод кластеризации в классической реализации.
Алгоритм был разработан в 1956 году математиком Гуго Штейнгаузом <ref>[http://www.laurent-duval.eu/Documents/Steinhaus_H_1956_j-bull-acad-polon-sci_division_cmp-k-means.pdf Steinhaus H. (1956). Sur la division des corps materiels en parties. Bull. Acad. Polon. Sci., C1. III vol IV: 801—804.]</ref>, и почти одновременно его изобрел Стюарт Ллойд <ref>[http://www-evasion.imag.fr/people/Franck.Hetroy/Teaching/ProjetsImage/2007/Bib/lloyd-1982.pdf Lloyd S. (1957). Least square quantization in PCM’s. Bell Telephone Laboratories Paper.]</ref>. Особую популярность алгоритм снискал после работы Джеймса Маккуина <ref>[https://pdfs.semanticscholar.org/a718/b85520bea702533ca9a5954c33576fd162b0.pdf MacQueen J. (1967). Some methods for classification and analysis of multivariate observations. In Proc. 5th Berkeley Symp. on Math. Statistics and Probability, pages 281—297.]</ref>
Алгоритм кластеризации k-means решает задачу распределения <math>N</math> наблюдений (элементов векторного пространства) на заранее известное число кластеров <math>K</math>. Действие алгоритма таково, что он стремится минимизировать среднеквадратичное отклонение на точках каждого кластера.
Алгоритм k-means является итерационным алгоритмом кластеризации. На каждой итерации происходит пересчет центра масс для каждого кластера, полученного на предыдущем шаге, затем исходные векторы заново распределяются по кластерам в соответствии с тем, какой из новых центров оказался ближе по выбранной метрике. Алгоритм завершается, когда на какой-то итерации не происходит изменения кластеров.

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

''Исходные данные:''
* множество наблюдений <math>X = \{x_1, x_2, ..., x_n\}</math>, где каждое наблюдение <math>x_i \in R^d, i = 1, ..., n</math>;
* количество кластеров <math>k \in N, k \leq n</math>

''Обозначения:''
* <math>S = \{S_1, S_2, ..., S_k \} </math> - множество кластеров, которые удовлетворяют следующим условиям:
** <math>S_i \bigcap S_j = \emptyset, i \neq j</math>;
** <math>X = {\bigcup \limits _{i = 1}^k S_i} </math>.
* <math>\mu_i \in R^d, i = 1, ..., k</math> - центр масс кластера <math>S_i</math>
* <math>d(u, v)</math> - расстояние между векторами <math>u \in R^m, v \in R^m</math>

''Выходные данные:''
* <math>L = (l_1, l_2, ..., l_n)</math> - набор меток, где метка <math>l_i \in N_{[1, k]}</math> - является порядковым номером кластера, к которому принадлежит вектор <math>x_i</math>: <math> x_i \in S_{l_i}</math>

 ''Цель алгоритма k-means'' - распределить наблюдения из входного множества <math>X</math> по <math>k</math> кластерам <math>S = \{S_1, S_2, ..., S_k \} </math> таким образом, чтобы сумма квадратов расстояний от каждой точки кластера до его центра масс по всем кластерам была минимальной:

<math>\arg\min_{S} \sum_{i=1}^{k} \sum_{x \in S_i} (d(x, \mu_i))^2 </math>,

Алгоритм состоит из следующих шагов:

# Инициализация центров масс На данном шаге задаются начальные значения центров масс <math> \mu_1^1, ..., \mu_k^1</math>. Существует несколько способов их выбора. Они будут рассмотрены ниже.
# t-ый шаг итерации:
#* Распределение векторов по кластерам На данном шаге каждый вектор <math>x_i \in X</math> распределяется в свой кластер <math>S_j^t</math> так, что: <math>l_i^t = \arg \min_{j} (d(x_i, \mu_j^t))^2 , j = 1, ..., k; i = 1, ..., n</math>
#* Пересчет центров масс кластеров На данном шаге происходит пересчет центров масс кластеров, полученных на предыдущем этапе: <math>\mu_i^{t+1} = \frac{1}{|S_i^t|} \sum_{x \in S_i^t} x</math>; <math>i = 1, ..., k</math>
# Критерий останова <math>\mu_i^t = \mu_i^{t+1},</math> для всех <math>i = 1, ..., k</math>

Способы инициализации начальных данных:
# Метод Forgy Случайным образом выбираются <math>k</math> векторов из множества наблюдений <math>X</math>. Эти вектора используются в качестве центров масс кластеров <math>\mu_1, ..., \mu_k</math>
# Метод случайного разбиения (Random Partition) <ref>[http://people.csail.mit.edu/tieu/notebook/kmeans/15_p600-hamerly.pdf Hamerly, G.; Elkan, C. (2002). "Alternatives to the k-means algorithm that find better clusterings". Proceedings of the eleventh international conference on Information and knowledge management (CIKM).]</ref> Каждый вектор <math>x_i, i = 1, .., n</math> случайным образом распределяется в кластер <math>S_j, j = 1, .., k</math>, затем для каждого кластера вычисляется его центр масс <math>\mu_j</math>.

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

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

Распределение векторов по кластерам заключается в следующем: для каждого вектора <math>x_i \in X, i = 1, ..., n</math> необходимо посчитать расстояние между этим вектором и центром масс кластера <math>\mu_j^t, j = 1, ..., k</math>. Следовательно, на каждой итерации необходимо выполнить <math>n * k</math> операций вычисления расстояния между векторами.

Пересчет центров масс кластеров заключается в следующем: для каждого кластера <math>S_i^t \in S, i = 1, ..., k</math> необходимо пересчитать кластер по формуле, приведенной в пункте выше. Следовательно, на каждой итерации необходимо выполнить <math>k</math> операций пересчета центров масс кластеров.

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

# Макрооперация "Расстояние между векторами" В данном алгоритме используется Евклидова метрика: <math>v \in R^m</math> и <math>u \in R^m: d(v, u) = \sqrt{\sum_{j=1}^{m} (v_j - u_j)^2} </math>;
# Макрооперация "Пересчет центра масс кластера" <math>\mu_i^{t+1} = \frac{1}{|S_i^t|} \sum_{x \in S_i^t} x</math>

Таким образом, алгоритм в терминах макроопераций выглядит следующим образом:
# Инициализация центров масс Метод Forgy: центры масс <math>\mu_j^1, j = 1, ..., k</math> выбираются случайным образом. Метод случайного разбиения: вектора <math>x_i \in X</math> случайным образом распределяются по кластерам. Для каждого кластера выполняется макрооперация "Пересчет центра масс кластера" для нахождения <math>\mu_j^1</math>.
# t-ый шаг итерации:
#* Распределение векторов по кластерам На данном шаге для каждого вектора <math>x_i \in X</math> k раз выполняется макрооперация "Расстояние между векторами" для нахождения расстояния между <math>x_i</math> и <math>\mu_j^t, j = 1, ..., k</math>. Затем для каждого вектора <math>x_i</math> находится минимальное расстояние.
#* Пересчет центров масс кластеров На данном шаге для каждого кластера выполняется макрооперация "Пересчет центра масс" для нахождения <math>\mu_j^{t+1}</math>.
# Критерий останова <math>\mu_i^t = \mu_i^{t+1},</math> для всех <math>i = 1, ..., k</math>

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

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

Входные данные : Множество векторов <math>X</math>, количество кластеров <math>k</math>
Выходные данные : Набор меток <math>L</math> принадлежности к кластеру
1 Инициализация центров масс <math>\mu_i^1, i = 1, ..., k</math>;
2 t := 1;
3 Для каждого вектора <math>x_i \in X, i = 1, ..., n:</math> <math>l_i^t = \arg \min_{j} (d(x_i,\mu_j^t))^2 , j = 1, ..., k</math>;
4 Для каждого кластера <math>S_i^t, i = 1, ..., k</math> выполняется макрооперация "Пересчет центра масс";
5 if (<math>\exists i = 1, ..., k: \mu_i^t \neq \mu_i^{t+1}</math>) {
6 t := t + 1;
7 goto 3;
8 } else {
9 stop;
10 };

Существующие способы оптимизации алгоритма <ref>[http://link.springer.com/chapter/10.1007/3-540-45643-0_13 Phillips S. J. Acceleration of k-means and related clustering algorithms //Workshop on Algorithm Engineering and Experimentation. – Springer Berlin Heidelberg, 2002. – С. 166-177.]</ref> <ref>[http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.187.3017&rep=rep1&type=pdf Hamerly G. Making k-means Even Faster //SDM. – 2010. – С. 130-140.]</ref> <ref>[http://cseweb.ucsd.edu/~elkan/kmeansicml03.pdf Elkan C. Using the triangle inequality to accelerate k-means //ICML. – 2003. – Т. 3. – С. 147-153.]</ref>

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

Подсчитаем количество операций для каждого шага алгоритма.

# Инициализация:
#* Метод Forgy: <math>N_{init} = 0</math>
#* Метод случайного разбиения:
#** Количество операций деления: <math>N^{/}_{init} = k * d</math>;
#** Количество операций сложения: <math>N^{+}_{init} = d * (n - k)</math>.
# Распределение <math>n</math> векторов <math>x_i \in R^d</math> по <math>k</math> кластерам на одной итерации:
#* Количество операций умножения: <math>N^{*}_{distr} = k * n * d</math>;
#* Количество операций сложения: <math>N^{+}_{distr} = k * n * (d - 1)</math>;
#* Количество операций вычитания: <math>N^{-}_{distr} = k * n * d</math>;
#* Количество операций взятия минимума: <math>N^{min}_{distr} = n * (k - 1)</math>.
# Пересчет центра масс <math>\mu_i \in R^d</math> для <math>k</math> кластеров на одной итерации:
#* Количество операций деления: <math>N^{/}_{update} = k * d</math>;
#* Количество операций сложения: <math>N^{+}_{update} = d * (n - k)</math>.

Следовательно, в случае если алгоритм сошелся за <math>i</math> итераций, получаем:
* Операций сложения/вычитания: <math>N^{+,-}_{k-means} = N^{+}_{init} + i*(N^{+}_{distr} + N^{-}_{distr} + N^{+}_{update}) = d * (n - k) + i*(k*n*(d-1)+k*n*d+d*(n-k)) \thicksim O(i*k*n*d)</math>
* Операций умножения/деления: <math>N^{*,/}_{k-means} = N^{/}_{init} + i*(N^{*}_{distr} + N^{/}_{update}) = k * d + i*(k*n*d+k*d) \thicksim O(i*k*n*d)</math>

Таким образом, [[глоссарий#Последовательная сложность|''последовательная сложность'']] алгоритма k-means для <math>n</math> <math>d</math>-мерных векторов и <math>k</math> кластеров за <math>i</math> итераций, требуемых для сходимости алгоритма: <math>O(i * n * k * d)</math>

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

Рассмотрим информационный граф алгоритма k-means.
На рисунке 1 представлена общая схема алгоритма k-means, согласно разделу [[#Схема реализации последовательного алгоритма|"Схема реализации последовательного алгоритма"]].
Вершина Init - этап инициализации.
Вершина Distribute - этап распределения векторов по кластерам.
Вершина Update - этап пересчета центров масс кластеров.
[[file:k-means-all.PNG|800px|thumb|center|Рисунок 1. Общая схема алгоритма k-means]]

На рисунке 2 представлен информационный граф этапа распределения векторов по кластерам. На вход данному этапу подают множество векторов <math>x_1, x_2, ..., x_n</math> из входных данных и множество центров масс кластеров <math>\mu^t_1, ..., \mu^t_k</math>, полученных с шага инициализации или с предыдущей итерации. Для каждой пары векторов <math>x_i, \mu^t_j, i = 1, ..., n; j = 1,..., k</math> считается расстояние между ними (вершина dist). Информационный граф вычисления расстояния между двумя векторами рассмотрен ниже (рисунок 3). Затем выполняется операция нахождения минимума (вершина min), в результате которой каждому вектору <math>x_i, i = 1, ..., n</math> приписывается метка <math>l^t_i</math>, равная порядковому номеру кластера <math>S^t_j, j = 1 ..., k</math>, которому принадлежит данный вектор: <math>x_i \in S^t_j</math>.
[[file:k-means-distribute.PNG|800px|thumb|center|Рисунок 2. Схема этапа распределения векторов по кластерам]]

На рисунке 3 представлен информационный граф вычисления расстояния между двумя векторами <math>x_i = (x_{i1}, ..., x_{id}), i = 1, ..., n</math> и <math>\mu^t_j = (\mu^t_{j1}, ..., \mu^t_{jd}) , j = 1, ..., k</math>. Выполняется операция поэлементного вычитания двух векторов (вершины -), затем возведение в квадрат (вершины sqr), затем суммирование полученных результатов (вершина +). На выходе получаем квадрат расстояния между векторами.
[[file:K-means-distance.PNG|800px|thumb|center|Рисунок 3. Схема вычисления расстояния между двумя векторами]]

На рисунке 4 представлен информационный граф этапа пересчета центров масс кластеров <math>\mu^t_1, \mu^t_2,..., \mu^t_k</math>. Для каждого кластера <math>S^t_j, j = 1, ..., k</math> выполняется операция суммирования (вершина <math>sum_j</math>) векторов, которые принадлежат данному кластеру. Кроме того, для каждого кластера выполняется операция определения количества элементов в нем (вершина <math>size_j</math>). Затем выполняется операция деления (вершина /). На выходе получаем новые центры масс кластеров <math>\mu^{t+1}_1, \mu^{t+1}_2,..., \mu^{t+1}_k</math>.
[[file:k-means-update.PNG|800px|thumb|center|Рисунок 4. Схема этапа пересчета центров масс кластеров]]

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

Вычислительное ядро алгоритма имеет большие возможности для параллелизма:
* Распределение векторов по кластерам: вектора <math>x_i, x_j, i \neq j; i, j = 1, ..., n</math> могут быть распределены по кластерам независимо друг от друга;
* Пересчет центров масс кластеров: центры масс кластеров <math>\mu_i, \mu_j, i \neq j; i, j = 1, ..., k</math> могут быть пересчитаны независимо друг от друга.

Однако, этап пересчета центров масс кластеров зависит от этапа распределения векторов по кластерам, так что эти этапы должны выполняться строго последовательно. Таким образом, параллельная сложность алгоритма может быть вычислена следующим образом: <math>N_{k-means} = i * (N_{distr} + N_{update})</math>, где <math>i</math> - количество итераций, необходимых для сходимости алгоритма, <math>N_{distr}</math> - параллельная сложность этапа распределения векторов по кластерам, <math>N_{update}</math> - параллельная сложность этапа пересчета центров масс кластеров.

Рассчитаем параллельную сложность <math>N_{distr}</math> этапа распределения векторов по кластерам в предположении наличия неограниченного числа процессоров для одной итерации. Для каждой пары векторов <math>(x_i, \mu_j), i = 1,...,n; j = 1, ..., k</math> операция вычисления расстояния выполняется независимо.
* При выполнении операция вычисления расстояния операции вычитания и умножения выполняются независимо друг от друга, поэтому требуется только одно вычитание и одно умножение. Число операций сложения: <math>N^{+}_{distr} = O(log(d))</math> согласно [[Нахождение_частных_сумм_элементов_массива_сдваиванием | алгоритму нахождения частичной суммы элементов массива путем сдваивания]];
* Для нахождения минимума среди <math>k</math> элементов требуется <math>O(log(k))</math> операций сравнения.
Таким образом, получаем, что <math>N_{distr} = O(log(k*d))</math>

Рассчитаем параллельную сложность <math>N_{update}</math> этапа пересчета центров масс кластеров в предположении наличия неограниченного числа процессоров для одной итерации. Нахождение центра масс <math>\mu_j, j = 1, ..., k</math> кластера <math>S_j</math> может выполняться независимо от нахождения центров масс других кластеров. Таким образом, получаем, что <math>N_{update} \leq O(log(n))</math> в худшем случае, когда почти все векторы находятся в одном кластере.

Итоговая параллельная сложность алгоритма: <math>N_{k-means} \leq i * (log(k*d) + log(n)) \thicksim O(i * log(k*d*n)); i</math> - количество итераций, необходимых для сходимости.

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

Входные данные:
* <math>n</math> векторов <math>x_i \in R^d, i = 1, ..., n</math>;
* число кластеров <math>k \in N_{[1,n]}</math>.

Объем входных данных:
<math>n * d</math> действительных чисел, 1 целое положительное число

Выходные данные:
* вектор меток <math>L \in N^n</math>.

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

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

;Достоинства:
# Алгоритм прозрачный и понятный, за счет чего очень прост в реализации;
# Алгоритм имеет высокую скорость работы в случае выбора оптимальных начальных значений центров масс кластеров.

;Недостатки:
# Число кластеров является входным аргументом алгоритма. Таким образом, некорректный выбор данного параметра может привести к плохим результатам работы алгоритма, поэтому зачастую проводят несколько прогонов алгоритма с разными значениями <math>k</math>, чтобы подобрать оптимальный;
# Алгоритм может сойтись к локальному минимуму (достижение глобального минимума не гарантируется);
# Результат сильно зависит от выбора начальных значений центров масс кластеров. Существует улучшенная версия алгоритма - k-means++ <ref>[http://ilpubs.stanford.edu:8090/778/1/2006-13.pdf Arthur, D.; Vassilvitskii, S. (2007). "k-means++: the advantages of careful seeding". Proceedings of the eighteenth annual ACM-SIAM symposium on Discrete algorithms. Society for Industrial and Applied Mathematics Philadelphia, PA, USA. pp. 1027–1035.]</ref>, которая предлагает свой способ нахождения начальных оптимальных значений центров масс кластеров;
# Чувствительность к выбросам и шумам, так как они учитываются при вычислении центров масс кластеров.

;[[глоссарий#Устойчивость|''Устойчивость'']]: Алгоритм является устойчивым к погрешностям во входных данных, так как при вычислении центров кластеров расстояния между объектами усредняются, что приводит к уменьшению ошибки. Алгоритм также является устойчивым к погрешностям, допускаемых при вычислениях, так как операция сложения на каждой новой итерации выполняется над входными данными.

;Сбалансированность: Множество входных векторов можно равномерно разделить между параллельными вычислителями. Центры всех кластеров можно распространить на все вычислители (так как их заведомо меньше, чем число входных векторов). В таком случае на каждой итерации определение для каждого объекта ближайшего кластера представляет собой вычисление расстояния от каждого входного вектора, находящегося на вычислителе, до каждого кластера, и является сбалансированной операцией. После данного этапа происходит пересчёт центров кластеров. Данная операция является несбалансированной в случаях, когда число объектов в одном из кластеров значительно больше числа объектов в других кластерах, из-за чего один кластер занимает большое число вычислителей, а остальные занимают по одному или несколько вычислителей. В таком случае для данного кластера потребуется вычислить центр [[Нахождение_частных_сумм_элементов_массива_сдваиванием | алгоритмом нахождения частичной суммы элементов массива путем сдваивания]]. Данная операция представляет несбалансированность порядка <math>O(log (k*n))</math>. После данного шага происходит сбалансированная операция рассылки центров кластеров на все вычислители.В идеальном случае параллелизации алгоритм не является сбалансированным, однако в реальных задачах, когда <math>n >> p</math>, где <math>p</math> - количество вычислителей, эта несбалансированность сглаживается наличием объектов из каждого кластера на каждом вычислителе

;Соотношение последовательной и параллельной сложности: <math>{O(n*d*k*i) \over O(log(n*d*k)*i)} \thicksim O \bigg( {n*d*k \over log(n*d*k)} \bigg)</math>

;[[глоссарий#Вычислительная мощность|''Вычислительная мощность'']]: Последовательный алгоритм: <math>{O(n*d*k*i) \over n*d+n+1} \thicksim {O(d*k*i) \over d+1} \thicksim O(k*i)</math>, где <math>n</math> - число входных векторов, <math>d</math> - размерность векторов, <math>k</math> - число кластеров, <math>i</math> - число итераций, требуемое для сходимостиПараллельный алгоритм: <math>O(log(n*d*k)*i) \over n*d+n+1</math>

;[[глоссарий#Детерминированность|''Детерминированность'']]: Алгоритм является недетерминированным, так как результат зависит от выбора исходных центров кластеров, а их оптимальный выбор неизвестен.

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
==== Локальность реализации алгоритма ====
===== Структура обращений в память и качественная оценка локальности =====
===== Количественная оценка локальности =====
=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===
Исследование проводилось на суперкомпьютере "Ломоносов" [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского Государственного Университета имени М.В. Ломоносова]

Набор данных для тестирования состоял из 946000 векторов размерности 2 (координаты на сфере)
Набор и границы значений изменяемых параметров запуска реализации алгоритма:

* число процессов (виртуальных ядер) [8 : 512];
* число кластеров [128 : 384].
В результате проведённых экспериментов был получен следующий диапазон эффективности реализации алгоритма:

* минимальная эффективность реализации <math>2,47%</math> достигается при делении исходных данных на 128 кластеров с использованием 512 процессов;
* максимальная эффективность реализации <math>7,13%</math> достигается при делении исходных данных на 352 кластера с использованием 8 процессов.
На следующих рисунках приведены графики производительности и эффективности выбранной реализации k means в зависимости от изменяемых параметров запуска.
[[file:kmeans_performance.jpg|thumb|center|720px|Рисунок 5. Параллельная реализация k means. Максимальная производительность. ]]
[[file:kmeans_efficiency.jpg|thumb|center|720px|Рисунок 6. Параллельная реализация k means. Максимальная эффективность. ]]
Исследовалась [https://github.com/serban/kmeans параллельная реализация алгоритма k means]. Для вычисления производительности в неё был вписан код на MPI, реализующий подсчёт числа операций с плавающей точкой: [https://github.com/like-a-bauss/kmeans окончательный текст программы].
Были получены следующие оценки масштабируемости реализации алгоритма k means:
*По числу процессов: <math>-0.02209</math>. Следовательно, с ростом числа процессов эффективность уменьшается.
*По размеру задачи: <math>0.01252</math>. Следовательно, с ростом размера задачи (числа кластеров) эффективность увеличивается.
*Общая оценка: <math>-0.00081</math>. Таким образом, с ростом и размера задачи, и числа процессов эффективность уменьшается.

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

Существуют следующие Open Source реализации алгоритма:
* [http://elki.dbs.ifi.lmu.de/ ELKI] - содержит реализацию алгоритма k-means на языке Java (в том числе реализацию улучшенного алгоритма k-means++)
* [http://www.cs.waikato.ac.nz/~ml/weka/ Weka] - содержит реализацию k-means на языке Java
* [http://mahout.apache.org/ Apache Mahout] - содержит реализацию k-means в парадигме MapReduce
* [https://spark.apache.org/ Spark Mllib] - содержит распределенную реализацию k-means
* [http://accord-framework.net/ Accord.NET] - содержит реализацию k-means на C# (в том числе реализацию улучшенного алгоритма k-means++)
* [https://github.com/mlpack/mlpack MLPACK] - содержит реализацию k-means на языке C++
* [http://opencv.org/ OpenCV] - содержит реализацию k-means на C++. А также есть обертки для языков Python и Java
* [https://www.scipy.org/ SciPy] - содержит реализацию k-means на языке Python
* [http://scikit-learn.org/ Scikit-learn] - содержит реализацию k-means на языке Python
* [http://julialang.org/ Julia] - содержит реализацию алгоритма k-means на языке Julia
* [https://www.gnu.org/software/octave/ Octave] - содержит реализацию k-means на языке Octave
* [https://www.r-project.org/ R] - содержит реализацию k-means на языке R
* [http://torch.ch/ Torch] - содержит реализацию k-means на языке Lua

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

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

2016-11-23T11:53:05Z

Zhum:

Участник:Astandrik/Алгоритм кластеризации, основанный на минимальном остовном дереве

2016-11-23T11:43:50Z

Zhum:

{{Assignment|Zhum}}

{{algorithm
| name = Алгоритм кластеризации, основанный на минимальном остовном дереве
| serial_complexity = <math> O(N^2 log(N)) </math>
| pf_height = <math> O(log(N)) </math>
| pf_width = <math> O(N) </math>
| input_data = <math> N </math>
| output_data = <math> N </math>
}}

Основные авторы описания: [[Участник:Astandrik|Стандрик Антон Сергеевич]]

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

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

Данный алгоритм предназначен для решения задач кластеризации. Говоря в общем, кластеризация — многомерная статистическая процедура, выполняющая сбор данных, содержащих информацию о выборке объектов, и затем упорядочивающая объекты в сравнительно однородные группы <ref>Классификация и кластер. Под ред. Дж. Вэн Райзина. М.: Мир, 1980. 390 с.</ref>.

Впервые идея использования минимального остовного дерева для кластеризации данных была преждожена C. T. Zah в 1971 году<ref name=zakh>C. T. Zahn, “graph-Theriotical methos for detecting and describing getalt clusters,” IEEE Trans. Computers, vol. 20, no. 1, pp. 68-86, 1971 </ref>. Этот метод широко используется исследователями при анализе изображений <ref>Y. Xu, V. Olman and E. C. Uberbacher, “A mentation using minimum spanning trees,” Image and Vission Computing, vol. 15, pp. 47-57,1997.</ref><ref>Zhi Min Wang, Yeng Chai Soh, Qing Song, Kang Sim, “Adaptive spatial information-theoretic clustering for image segmentation,” Pattern Recognition, vol. 42, no. 9, pp. 2029-2044, 2009.</ref>, а также при анализе биологических данных <ref>Y. Xu, V. Olman and D. Xu, “Clustering gene expression data using a graph-Theriotic approach: An application of minimum spanning trees,” Bioinformatics, vol. 18, no. 4, pp. 536-545, 2002.</ref>.

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

# Разбиение входных векторов на пары и вычисление расстояний в них. Для этого небходим выбор метрики пространства, в котором осуществляется кластерный анализ. В качестве примеров метрик можно привести:
#* Метрика Евклида: <math>d_{ij} = \sqrt{\sum^n_{k=1}(x_{ik} - x_{jk})^2}</math>
#* Метрика city-block (манхэттенская метрика): <math>d_{ij} = \sum^n_{k=1}|x_{ik} - x_{jk}| </math>
#* Метрика Брея-Картиса: <math>d_{ij} = \sum^n_{k=1}\frac{|x_{ik} - x_{jk}|}{|x_{ik} + x_{jk}| }</math>
# Построение минимального остовного дерева по заданному множеству. Существует три основных алгоритма [[Построение минимального остовного дерева (MST) | построения минимального остовного дерева]]:
#* [[Алгоритм Прима]]
#* [[Алгоритм Крускала]]
#* [[Алгоритм Борувки]]
# Разделение полученного дерева на несвязное множество поддеревьев в соответствии с некоторой стратегией. Можно выделить три популярные стратегии кластеризации:
#* SEMST<ref>Asano, M.K.T., Bhattacharya, B., Yao, F.: Clustering algorithms based on minimum and maximum spanning trees. In: In Proceedings of the fourth annual symposium on Computational Geometry. (1998) 252–257</ref> (standard Euclidean minimum spanning tree clustering algorithm) - предполагается, что нам заранее известно число кластеров. В таком случае, если число кластеров равно <math>k</math>, то из полученного в первом пункте остовного дерева удаляются <math>k-1</math> связей с наибольшим весом.
#* CEMST<ref>Ye, B., Chao, K.M.: Spanning Trees and Optimization Problems. Chapman and
Hall (2004)</ref>(The maximum cost minimum spanning tree) - Работает так же как и SEMST, однако вместо веса вершины используется её стоимость, которая вычисляется следующим образом: Пусть ребро <math>e = (x_{i}, x_{j})</math>, тогда <math>cost(e) = w(e) * degree(x_{i}) * degree(x_{j})</math>. Далее, зная число кластеров <math>k</math> и стоимости рёбер, удаляются <math>k-1</math> рёбер с максимальной стоимостью.
#* ZEMST<ref name=zakh /> (The Zahn’s minimum spanning tree) - от двух предыдущих эта стратегия отличается тем, что здесь число кластеров не известно заранее, а вычисляется в процессе кластеризации. Его суть в том, что удаляются те рёбра, веса которых значительно превосходят средний вес ребра в соседних поддеревьях.

==== Достоинства ====

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

[[File:Selection_117_.png|frame|center|alt=Point-connected clusters| Слева направо: Рисунок 1: Начальные данные. Рисунок 2: построенное минимальное остовное дерево. Рисунок 3: разбиение на кластеры путём удаления самых длинных связей.]]

==== Недостатки ====

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

Кроме того, существуют наборы данных, на которых популярные алгоритмы (SEMST, CEMST, ZEMST) не дают правильного результата, и для которых требуется применение более сложных алгоритмов, к числу которых можно отнести, например, алгоритм HEMST <ref>Clustering with Minimum Spanning Trees Yan Zhou, Oleksandr Grygorash, Thomas F. Hain, Meador Inge Zach Jorgensen School of Computer and Information Sciences University of South Alabama, Mobile, AL 36688 USA Urban Insight Inc. 5657 Wilshire Blvd Ste 290, Los Angeles, CA 90036</ref> с временем работы <math>O(n^2 * log(n))</math>.

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

[[File:Selection_116_.png|frame|center|alt=Point-connected clusters| Правильное разбиение на два кластера.]]

[[File:Selection_115_.png|frame|center|alt=Point-connected clusters| Неверное разбиение на один кластер.]]

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

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

Исходные данные: набор векторов размерности <math>n</math> : <math>(a_1, a_2, ..., a_n)</math>, где <math> a_j \in \mathbb {R} \quad \forall j \in [1,n] </math>.

Вычисляемые данные: Сгруппированные по кластерам данные.

==== Основные обозначения ====

* <math>E</math> - множество рёбер.
* <math>V</math> - множество вершин.
* <math>G = (V,E) </math> - неориентированный граф, заданный множеством вершин <math>V</math> и множеством рёбер <math>E</math>
* <math>MST(G)</math> (Minimum Spanning Tree) - минимальное остовное дерево графа <math></math>. Остовное дерево — ациклический связный подграф данного связного неориентированного графа, в который входят все его вершины. Минимальное остовное дерево в связанном взвешенном неориентированном графе — это остовное дерево этого графа, имеющее минимальный возможный вес, где под весом дерева понимается сумма весов входящих в него рёбер.
* <math>MSF(G)</math> (Minimum Spanning Forest) - набор минимальных остовных деревьев для всех компонент связности графа <math> G </math>

В описании алгоритмов этой статьи часто используется термин "построение MST", подразумевая, что на самом деле в результате построения может получиться как одна компонента связности (MST), так и множество компонент связности (MSF).

==== Алгоритмы кластеризации ====
'''SEMST'''(standard Euclidean minimum spanning tree) - простейший алгоритм, основанный на заранее известном числе кластеров <math> k </math>. Путём удаления <math> k - 1 </math> связей с наибольшим весом предполагается разбиение остовного дерева на нужное количество кластеров. Иными словами минимальное остовное дерево разбивается на <math> k </math> поддеревьев: <math> G = \{G_1,G_2,...,G_k\} </math> путём минимизации суммы всех весов: <math> W = \sum ^k_{l=1} \sum _{x_i,x_j \in V_l} w_{x_i,x_j} -> min </math>, где <math> V_l </math> - множество вершин в поддереве <math> G_l </math>. В конце такой процедуры каждое множество <math> V_l </math> становится кластером <math> C_l </math>. Поскольку (в случае использования алгоритма Крускала для построения остовного дерева) рёбра перед началом кластеризации уже отсортированы, для удаления наибольших <math> k </math> рёбер требуется <math> O(k) </math> операций, и для распределения получившихся вершин по кластерам требуется время <math> O(n) </math>.'''

'''CEMST'''(maximum cost Euclidean minimum spanning tree) - Работает в точности, как и SEMST, но здесь вместо весов рёбер используется т.н. "стоимость", которая высчитывается следующим образом: если ребро <math> (x_i, x_j) </math> соединяет вершины <math> x_i </math> и <math> x_j </math>, то его "стоимость" считается как: <math> Cost_{x_i, x_j} = w_{x_i,x_j} * Deg(x_i) * Deg(x_j) </math>, где <math> Deg(x_i) </math> - степень вершины <math> x_i </math> (т.е. количество рёбер графа G, инцидентных вершине <math> x_i </math>). В остальном алгоритм действует точно так же, как и SEMST, удаляя <math> k-1 </math> рёбер с наибольшей "стоимостью". Сложность <math> O(k) </math> . Алгоритм направлен на удаление рёбер, соединяющих высоко нагруженные (с точки зрения количества инцидентных рёбер) вершины.

'''ZEMST''' (The Zahn’s maximum spanning tree (Zahn, 1971)) <ref> Attribute Clustering Based on Heuristic Tree Partition Jorge Cordero H. and Yifeng Zeng Department of Computer Science Aalborg University 9220 Aalborg, Denmark</ref> - отличается от двух предыдущих алгоритмов в первую очередь тем, что здесь количество кластеров заранее не известно, но определяется исходя из данных. Данный алгоритм не является жадным, в отличие от первых двух, так как в нём рассматривается не только само ребро и его вес, а также и поддеревья, которые соединены этим ребром. То есть для ребра <math> (x_i, x_j) </math> рассматриваются поддеревья <math> N_i = (V_{N_i}, E_{N_i}), N_j = (V_{N_j}, E_{N_j}) </math>, где <math> N_i </math> - поддерево глубины(высоты) <math> d </math>(величина d определяется эмпирически), состоящее из всех достижимых из вершины <math> x_j </math> вершин за <math> d </math> шагов через все достижимые из неё рёбра (исключая само ребро <math> (x_i, x_j) </math>).
Введём обозначения:
*<math>\overline{w_{N_i}} = \frac{\sum_{(x_r, x_s) \in E_{N_j}}w_{x_r,x_s}}{|E_{N_j}|} </math> - средний вес ребра в поддереве <math> N_i </math>
*<math>\sigma_{N_i} = \sqrt{\frac{\sum_{(x_r, x_s) \in E_{N_j}}(w_{x_r,x_s} - \overline{w_{N_i}})^2}{|E_{N_j}|}} </math> - стандартное отклонение веса ребра в поддереве <math> N_i </math>
Ребро <math> (x_i, x_j) </math> удаляется из списка в случае, если выполняется хотя бы одно из двух условий:
#<math> w_{x_i,x_j} > \overline{w_{N_i}} - \sigma_{N_i} </math>
#<math> w_{x_i,x_j} > \overline{w_{N_j}} - \sigma_{N_j} </math>
#<math> w_{x_i,x_j} > \frac{\sum_{(x_r, x_s) \in E_i \cup E_j}w_{x_r,x_s}}{|E_i \cup E_j|} </math>

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

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

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

# Приведение задачи наборе векторов данных к задаче о поиске минимального остовного дерева в графе (то есть нахождение расстояний между всеми парами данных векторов с использованием выбранной метрики, и запись этого расстояния как веса ребра, соединяющего эти вершины). Последовательная сложность: <math> O(n^2) </math>
# Поиск минимального остовного дерева. Последовательная сложность: <math> O(E*log(E)) </math>
# Разбиение остовного дерева на кластеры. Последовательная сложность зависит от реализации. (от <math> O(1) </math> в случае SEMST до <math> O(n^2) </math> в случае ZEMST).

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

В реализации алгоритма используются следующие структуры данных:
#'''Узел'''(Node)(Вершина) - Представляется набором координат в выбранном пространстве.
#'''Ребро'''(Edge) - Представляется: двумя индексами вершин, которые соединяет; своим весом; флагом, который указывает, входит ли данное ребро в минимальное остовное дерево.

В дальнейшем описании алгоритма используются следующие макрооперации:
#Вычисление расстояния между вершинами.
#Добавление ребра в граф - Осуществляется путём выставление специального флага у соответствующего ребра в true;
#Удаление ребра из графа - Операция, обратная к добавление: соответствующий флаг устанавливается в false. В начальный момент времени у всех рёбер флаг установлен в false, что означает отсутствие рёбер в графе.

Следующие три используемые операции относятся к реализации алгоритма Крускала при помощи леса непересекающихся множеств. Подробнее об этой структуре и связанных операциях можно почитать, например, здесь <ref> Томас Кормен и др. Алгоритмы: построение и анализ = INTRODUCTION TO ALGORITHMS. — 2-е изд. — М.: «Вильямс», 2006. — С. 1296. — ISBN 0-07-013151-1. (Глава 21. Раздел 21.3: "Леса непересекающихся множеств) </ref>, в данном пункте они будут только перечислены:
#Создание дерева с одним узлом - Make-Set
#Объединение компонент связности - Union
#Поиск компонент связности - Find-Set

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

<source lang="cpp">
int N; // Размер входных данных
int number_of_clusters; // Число кластеров
int size = N* (N-1) / 2; // Количество связей в полном графе
Node nodes[N]; // Вершины(точки), заданные начальными условиями
Edge edges[size]; // Все расстояния между вершинами
vector<Edge> MST; // Рёбра минимального остовного дерева
read_data(&nodes, file_name); // Считывание начальных данных

//----------------Часть 1--------------//
for(int i = 0; i < N-1; i++) {
for(int j = i+1; j < N; j++) {
double distance = getDistance(node[i], node[j]); // Вычисление расстояния между вершинами
edges[i*N + j] = Edge(i,j,distance); // Запись значения расстояния в массив
}
}

//----------------Часть 2--------------//
sort(edges, size); // Сортировка рёбер графа в порядке возрастания
for(int i = 0; i < size; i++) { // Обходим список рёбер по возрастанию
if(find_set(edges[i].first) != find_set(edges[i].second)) { // Если вершины принадлежат разным подграфам - связываем их
Union(edges[i].first, edges[i].second); // Если вершины принадлежат разным подграфам - связываем их
MST.push_back(edges[i]); // Запись использованного ребра в минимальное остовное дерево
edges[i]->is_in_MST = true; // Запись использованного ребра в минимальное остовное дерево
}
}

//----------------Часть 3--------------//
for(int i = MST.size() - 1; i > MST.size() - 1 - number_of_clusters; i--) {
remove_edge(MST, i); // Удаление самых длинных рёбер из MST - формирование кластеров
}
write_data(MST); // Запись выходных данных
</source>

Как описано в пункте 1.3, весь описываемый алгоритм (начиная от момента получения данных и заканчивая моментом, когда данные отданы на вывод), может быть условно разделён на три части. В то время как первая часть может быть достаточно эффективно решена "в лоб", вторая и третьи части, как указано в пункте 1.1, могут иметь альтернативы. В данном фрагменте кода подробно описано использование [[Алгоритм Крускала | Алгоритма Крускала]] для построения MST, и алгоритма SEMST для разбиения на кластеры.

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

Как и в остальных пунктах, здесь сложность алгоритма состоит их суммы сложностей трёх его составных частей. Если оценивать сложность асимптотически в зависимости от входных данных, то:

<math> T(n) = O(n^2) + O(\frac{n (n-1)}{2})log(\frac{n (n-1)}{2})) + O(1) </math>

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

<math> O(\frac{n (n-1)}{2} log(\frac{n (n-1)}{2}) = O(n^2 log(n^2)) = O(2 n^2 log(n)) = O(n^2 log(n)) </math>

Отсюда видно, что для входных данных этого алгоритма асимптотические сложности алгоритмов Крускала, Прима и Борувки совпадают.

Таким образом, последовательная сложность алгоритма: <math> O(n^2 log(n)) </math>

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

[[File:Graph_algo10.png|frame|center|alt=Алгоритм| Макро-описание параллельного алгоритма кластеризации]]

=== Ресурс параллелизма алгоритма ===
Данная задача хорошо распараллеливается благодаря тому, что все "тяжелые" вычислительные задачи, начиная с момента считывания входных данных, можно распределить по процессам практически равномерно. Это достигается за счет следующей реализации:
#Мастер-процесс считывает входные данные и отправляет их остальным процессам с помощью MPI_Broadcast.
#Все пары точек разбиваются так, что каждому процессу достается одинаковое количество пар.
#Каждый процесс-рабочий строит MST на своём наборе пар точек.
#Процессы объединяют свои деревья по алгоритму, изображенному в информационном графе. То есть объединение осуществляется последовательно между группами размера <math>2^k</math>, где <math> k \in 1,2,..log_2p</math>, где p - число процессов.

Таким образом '''высота Ярусно-Параллельной формы''' (при наличии <math> p = 2^i </math> процессоров) будет <math> 1 + i + 1 + 1 </math>.
В то же время, как будет показано в пункте 1.10, оптимальное количетво процессоров может быть оценено по формуле <math> p(N) \approx \sqrt {\frac{N-1}{2}} </math>. Тогда '''ширину Ярусно-Параллельной формы''' можно оценить как <math> O(\sqrt{N}) </math>. Учитывая приближенную формулу для числа процессоров, оценим высоту ЯП при помощи соотношения <math> 2^i \approx \sqrt {\frac{N-1}{2}} </math>. Тогда высоту ЯП можно оценить как <math> O(log(N)) </math>.

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

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

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

==== Входные данные ====
В качестве входных данных программе дается множество векторов <math> [x_1,x_2,...,x_N]</math>, где <math> x_j = (a_{1j}, a_{2j}, ..., a_{nj})</math> размерности <math>n</math>. Для удобства изучения свойств алгоритма и отображения результатов можно брать массив векторов размерности 2. В этом случае наглядность будет обеспечена естественной возможностью отобразить вектора в плоскости.

Кроме того может оказаться полезным особым образом подготовить данные перед анализом (удаление "шумов", выбросов и масштабирование данных по тем или иным координатам).
==== Выходные данные ====
Выходными данными программы будет множество <math> M = ((x_1,x_2,..,x_k),(x_{k+1},...),...) </math>, состоящее из сгруппированных по кластерам векторов из входных данных.

В конкретной программе это может быть реализовано путём записи <math> N </math> строк вида <math>(x_{i}, Cluster-Number)</math> в выходной файл.

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

Одним из трудных мест параллельной реализации является правильный выбор количества процессов. Для удобства анализа рассматривается число процессоров <math> p = 2^i </math>, где <math> i \in \mathbb {N} </math>. Ясно, что такое допущение не повлияет на качество анализа, так как другое число процессоров лишь приведет к незначительным накладным расходам, сложность которых асимптотически стремится к нулю. В таком случае можно также ввести допущение о размере входных данных: <math> N = 2^j </math>, где <math> j \in \mathbb {N}, j > i </math>. В этом случае MST-часть дерева графа алгоритма является идеально сбалансированным бинарным деревом. Тогда сложность можно оценить следующим образом:
#На первом этапе каждый процесс производит расчет на <math> 2^{j - i} * (2^j - 1)</math> рёбрах, получая локальное MST(или MSF) на не более чем <math> N </math> вершинах.
#Далее следует <math> i = log_2(2^i) </math> шагов объединения не более чем по N рёбер в каждом.

Таким образом, задача эффективного запуска алгоритма состоит в том, чтобы найти оптимальный баланс между количеством расчетов на каждом узле на первом шаге и общим количеством объединений поддеревьев. Пусть дано <math> p = 2^i </math> вычислительных узлов и <math> N = 2^j </math>. В таком случае каждый узел получает считает <math> 2^{j - i} * (2^j - 1)</math> рёбер на первом шаге. Высота части ЯП-формы, отвечающей за MST, равна <math> i </math>. Тогда всего будет <math> i </math> уровней объединений MST с числом рёбер не более чем <math> 2N </math> для каждого вычислительного узла.

==== Оценка скорости работы параллельного алгоритма ====

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

*<math> T'(N,p) = \frac{N(N - 1)}{2 p} * logN + 2N*log(N) * log_2p</math>.

Объяснение формулы: первое слагаемое, исходя из оценки для сложности алгоритма Прима: <math> O(ElogV) </math>, - время(число операций) расчета на каждом процессоре на первом шаге. После первого шага (поскольку построено минимальное остовное дерево) каждый процесс передает не более чем <math> N </math> рёбер дальше. Второе слагаемое: каждый процесс после первого шага получает не более чем <math> 2N </math> рёбер (от двух процессоров при объединении), и всего таких шагов объединения не более чем <math> log_2p </math>, при этом предполагается, что сложностью объединения <math> 2N </math> рёбер на каждом шаге можно пренебречь (или допустить его пренебрежительно малым), поскольку предполагается, что все процессы после первого шага получают свою часть уже отсортированных рёбер(то есть наибольшее ребро процессора <math> i </math> меньше наименьшего ребра процессора <math> i+1 </math>), и объединение будет просто конкатенацией блоков памяти.

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

1. <math> N = 10^4</math>
[[File:График1_.JPG|frame|center|alt=Алгоритм| По оси абсцисс: количество вычислительных узлов. По оси ординат: время вычислений. При фиксированном <math> N </math>]]

2. <math> N = 1.5*10^4 </math>
[[File:График2_.JPG|frame|center|alt=Алгоритм| По оси абсцисс: количество вычислительных узлов. По оси ординат: время вычислений. При фиксированном <math> N </math>]]

Из этих графиков становится видно качественное поведение времени вычислений при увеличении числа процессоров. Можно заметить, что для каждого набора входных данных есть число процессоров, минимизирующее время вычислений. Но в то же время видно, что при слишком большом количестве процессоров алгоритм начинает работать хуже, чем при меньшем. Это вполне понятно: Слишком большое число процессоров порождает большое число обменов между ними, объединений деревьев, сортировок, и т.д. Таким образом, именно эта часть <math> 2N*log(N) * log_2p </math> оценки времени вычислений отвечает за ухудшение эффективности алгоритма при числе процессоров, которое больше оптимального. Кроме того, видно, что при увеличении объёма входных данных оптимальное количество процессоров также увеличивается: количество обменов и слияний деревьев компенсируется уменьшением вычислительной нагрузки на каждый отдельный процессор.

Благодаря такой оценке становится возможным оценить примерное оптимальное число процессоров <math> p </math> в зависимости от объёма входных данных <math> N </math>. Продифференцировав приближенную формулу <math> T'(N,p) = \frac{N(N - 1)}{2 p} * logN + 2N*log(N) * log_2p </math> по <math> p </math> и приравняв производную нулю, получим следующее выражение для оптимального числа процессоров:

<math> p(N) \approx \frac{N-1}{4} </math>

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

Согласно определению, [[глоссарий#Вычислительная мощность|''вычислительная мощность'']] алгоритма равна отношению числа операций к суммарному объему входных и выходных данных. В то же время, учитывая вышесказанное, видно, что число операций в данном алгоритме зависит не только от объема входных данных, но также от числа процессоров. Таким образом, имеет смысл оценить вычислительную мощность как в случае оптимального числа процессоров, так и в общем случае числа процессоров, равного <math> p </math>.

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

<math> \frac{N(N - 1)}{2} * logN + \sum_{i = 0}^{log_2p}(2N*log(N) * \frac{p}{2^i}) = N logN (\frac{N-1}{2} + 2 * p * \sum_{i = 0}^{log_2p}( \frac{1}{2^i})) = </math> {переходя к пределу в сумме} <math> \approx N logN (\frac{N-1}{2} + 2 * p) </math>

Таким образом, вычислительная мощность в общем случае: <math> \approx \frac{N logN (\frac{N-1}{2} + 2 * p)}{2N} = \frac{logN *(\frac{N-1}{2} + 2 * p)}{2} </math>

В случае оптимального числа вычислительных узлов: <math> \approx \frac{N logN (\frac{N-1}{2} + \frac{N-1}{2})}{2N} = \frac{logN * (N-1)}{2}</math>

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

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

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

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

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

В настоящей статье приводится исследование самостоятельной реализации алгоритма: [http://pastebin.com/gH09k6id main.cpp]. Запуск производился на системе IBM Blue Gene/P.
Для генерации данных использовался скрипт на питоне [http://pastebin.com/5YNxqqpA testGenerator]. Для отображения кластеров использовалась библиотека matplotlib и скрипт [http://pastebin.com/mTDZ6bqp graphDraw].

IBM Blue Gene/P — массивно-параллельная вычислительная система, которая состоит из двух стоек, включающих 2048 четырехъядерных вычислительных узлов, с пиковой производительностью 27,9 терафлопс.

Характеристики системы:
* две стойки с вычислительными узлами и узлами ввода-вывода
* 1024 четырехъядерных вычислительных узла в каждой из стоек
* 16 узлов ввода-вывода в стойке (в текущей конфигурации активны 8, т.е. одна I/O-карта на 128 вычислительных узлов)
* программирование с использованием MPI, OpenMP/pthreads, POSIX I/O
* высокая энергоэффективность: ∼ 372 MFlops/W

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

Вычислительной узел:
* четыре микропроцессорных ядра PowerPC 450 (4-way SMP)
* пиковая производительность: 4 ядра x 3,4 GFlop/sec на ядро = 13,6 GFlop/sec
* пропускная способность памяти: 13,6 GB/sec
* 2 ГБ общей памяти
* 2 x 4 МБ кэш-памяти 2-го уровня (в документации по BG/P носит название L3)
* легковесное ядро (compute node kernel, CNK), представляющее собой Linux-подобную операционную систему, поддерживающую значительное подмножество Linux-совместимых системных вызовов
* асинхронные операции межпроцессорных обменов (выполняются параллельно с вычислениями)
* операции ввода-вывода перенаправляются I/O-картам через сеть коллективных операций

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

[[File:Performance3.JPG|frame|center|alt=Алгоритм| Производительность алгоритма]]

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

[[File:Timeline1.JPG|frame|center|alt=Алгоритм| Вычислительное время алгоритма для <math>N = 17000</math>]]
[[File:Снимок2.JPG|frame|center|alt=Алгоритм| Вычислительное время алгоритма для <math>N = 3000</math>]]

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

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

=== Существующие реализации алгоритма ===
Как таковые, алгоритмы самого процесса кластеризации в популярных библиотеках (таких, как Scipy, Numpy или Boost) не реализованы (в отличие от других алгоритмов кластеризации). Однако, можно найти пользовательские любительские реализации (некоторые из которых приведены в списке ниже). Кроме того, существует масса реализаций основного коспонента данного алгоритма - вычисления MST - на многих языках программирования в разных библиотеках. Ссылки на некоторые из этих реализаций(перечислить все было бы невозможно) также приведены в списке ниже.

*[https://github.com/jakevdp/mst_clustering Minimum Spanning Tree Clustering in Python Author: Jake VanderPlas]
*[https://github.com/amueller/information-theoretic-mst Information Theoretic Clustering using Minimum Spanning Trees]
*[http://www.boost.org/doc/libs/1_51_0/libs/graph/doc/prim_minimum_spanning_tree.html C++ Boost library prim_minimum_spanning_tree]
*[http://www.boost.org/doc/libs/1_35_0/libs/graph/doc/kruskal_min_spanning_tree.html C++ Boost library kruskal_minimum_spanning_tree]
*[http://jgrapht.org/javadoc/org/jgrapht/alg/PrimMinimumSpanningTree.html Java library JGraphT PrimMinimumSpanningTree]
*[http://jgrapht.org/javadoc/org/jgrapht/alg/KruskalMinimumSpanningTree.html Java library JGraphT KruskalMinimumSpanningTree]
*[http://docs.scipy.org/doc/scipy-0.15.1/reference/generated/scipy.sparse.csgraph.minimum_spanning_tree.html SciPy library MST]

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

Участник:SenderovichNikita/Алгоритм кластеризации, основанный на построении каркаса

2016-11-23T11:12:37Z

Zhum:

{{Assignment|Zhum}}

{{algorithm
| name = MST-Кластеризация
| serial_complexity = <math>O(N^2\log N)</math>
| pf_height = <math>O(\log^2 N)</math>
| pf_width = <math>O(N^2)</math>
| input_data = <math>O(N)</math>
| output_data = <math>O(N)</math>
}}

Автор статьи: [[Участник:SenderovichNikita|Сендерович Никита Леонидович]]

Данный документ содержит описание алгоритма кластеризации, основанного на построении [[Построение минимального остовного дерева (MST)|минимального остовного дерева]] (каркаса, остова, кратчайшего незамкнутого пути, минимального покрывающего дерева, англ. Minimum Spanning Tree (MST)) - эвристического графового алгоритма построения разбиения множества объектов на такие непересекающиеся подмножества объектов, что объекты, принадлежащие одному подмножеству, схожи по заданной метрике в большей степени, чем объекты, принадлежащие разным группам.

Как и все алгоритмы кластеризации, данный алгоритм может быть применён для решения задач кластерного анализа, выделения типовых и нетипичных объектов в рассматриваемой выборке объектов. Его достоинствами по сравнению с другими аналогичными алгоритмами машинного обучения являются наглядность, идейная простота, возможность контролировать число кластеров. Главным недостатком является ограниченная применимость: алгоритм лучше всего подходит для выделения кластеров типа сгущений или лент, наличие разреженного фона или узких перемычек между кластерами может приводить к неадекватному с точки зрения аналитика результату<ref>[http://www.ccas.ru/voron/download/Clustering.pdf Воронцов К.В. "Лекции по алгоритмам кластеризации и многомерного шкалирования"]</ref>. Другим недостатком является высокая вычислительная сложность: на выборках более 100 тыс. объектов без применения параллельных вычислений применить алгоритм невозможно. Рассмотрению соответствующих параллельных алгоритмов и посвящена данная статья.

== Свойства и структура алгоритма ==
=== Общее описание алгоритма ===
Рассматривается выборка <math>X = \{x_i\}, i = 1, 2, \ldots, N</math>, состоящая из <math>N</math> объектов с заданной симметричной неотрицательной функцией расстояния <math>\rho</math>. Данную выборку можно рассматривать как связный неориентированный взвешенный граф <math>G</math>, множество вершин которого совпадает со множеством объектов выборки, веса рёбер соответствуют значениям функции расстояния между соответствующими вершинами.

Также должно быть задано искомое число кластеров <math>K</math>. [[file:MSTClusteringFull.png|thumb|700px|Рис.1. Ключевая идея алгоритма кластеризации на основе построения остовного дерева, разбиение на 3 кластера]]

Идея рассматриваемого алгоритма кластеризации очень проста:
* с помощью какого-либо алгоритма на определённом выше графе строится [[Построение минимального остовного дерева (MST)| минимальное остовное дерево]]
* из полученного дерева выбрасывается <math>K - 1</math> ребро с наибольшими весами, что приводит к появлению в остовном дереве <math>K</math> компонент связности, каждая из которых объявляется кластером

Иллюстрация работы алгоритма приведена на рис. 1. В данном случае рассматриваются 13 объектов на евклидовой плоскости, построено остовное дерево, после чего из него выброшены 2 наиболее длинных ребра и получены три кластера.

Существуют различные модификации описанного алгоритма, связанные с другим алгоритмом конструирования исходного графа или условием выбрасывания рёбер из построенного остовного дерева. Например, число <math>K</math> может быть полезно определить не изначально, а подобрать, рассматривая отсортированную по убыванию последовательность весов рёбер в остовном дереве: если имеется резкое уменьшение весов, то можно удалить все рёбра до него. Формализацией такого подхода является алгоритм ZEMST<ref>[http://www4.ncsu.edu/~zjorgen/ictai06.pdf Minimum Spanning Tree Based Clustering Algorithms]</ref>. Однако в дальнейшем ограничимся анализом определённого выше простейшего варианта.

=== Математическое описание алгоритма ===
Пусть задан связный неориентированный граф на множестве объектов <math>G = (X, E)</math> с неотрицательными весами рёбер <math>\rho(e) = \rho(x_i, x_j) \geqslant 0</math>.

Наиболее частый используемый на практике сценарий следующий:
* каждый объект описывается <math>d</math>-мерным вектором в пространстве
* используется функция расстояния <math>\ell_p</math>

Например, случай, когда в качестве метрики выбирается евклидова метрика <math>\ell_2</math> в литературе называется EMST - Euclidean Minimum Spanning Tree.

Хотя в некоторых задачах возможна ситуация, когда данный граф не является полным (по каким-то причинам определены не все расстояния между вершинами), но в описанных типовых случаях граф является полным, содержит <math>\frac{N(N - 1)}{2} = O(N^2)</math> рёбер.

==== Обзор алгоритмов поиска минимального остова ====
Для поиска минимального остовного дерева на практике используется следующие три похожих друг на друга алгоритма и их комбинации: [[Алгоритм Прима]]<ref>Prim, R C. “Shortest Connection Networks and Some Generalizations.” Bell System Technical Journal 36, no. 6 (November 1957): 1389–1401. doi:10.1002/j.1538-7305.1957.tb01515.x.</ref>, [[Алгоритм Крускала]]<ref>Kruskal, Joseph B. “On the Shortest Spanning Subtree of a Graph and the Traveling Salesman Problem.” Proceedings of the American Mathematical Society 7, no. 1 (January 1956): 48–50. doi:10.1090/S0002-9939-1956-0078686-7.</ref> и [[Алгоритм Борувки]]<ref>Borůvka, Otakar. “O Jistém Problému Minimálním.” Práce Moravské Přírodovědecké Společnosti III, no. 3 (1926): 37–58.</ref>.

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

'''В алгоритме Прима''' рассматривается текущее остовное дерево <math>T</math>. Изначально <math>T</math> состоит из одной вершины, выбранной произвольно. Далее на каждом шаге отыскивается минимальное ребро, ровно один из концов которого принадлежит <math>T</math>, оно добавляется в <math>T</math> вместе со вторым своим концом. Алгоритм завершается через <math>N - 1</math> шаг - ровно столько рёбер в дереве на <math>N</math> вершинах. Последовательная реализация, при которой минимальное ребро на каждом шаге ищется полным перебором рёбер, исходящих из <math>T</math>, имеет сложность <math>O(N^3)</math> на полном графе. Алгоритм можно ускорить, если поддерживать двоичное дерево поиска по рёбрам, ровно один из концов которых принадлежит <math>T</math>. Тогда при добавлении очередной вершины в <math>T</math> необходимо добавить в двоичное дерево не более чем <math>N - 1</math> новое ребро за <math>O(N \log N)</math>, а выбор минимума осуществляется за <math>O(\log N)</math>. Поскольку шаг добавления вершины повторяется <math>N</math> раз, итоговая сложность <math>O(N^2 \log N)</math>.

'''В алгоритме Крускала''' остов <math>T</math> изначально пуст, и в остов на каждом шаге добавляется вместе со своими концами минимальное ребро, имеющееся в графе, не нарушающее свойства ацикличности уже выбранного на предыдущих шагах леса <math>T</math>. Через <math>N - 1</math> шаг лес <math>T</math> гарантированно станет связным деревом. Если искать минимум полным перебором по <math>O(N^2)</math> рёбрам полного графа, сложность получится <math>O(N^3)</math>. Если же предварительно отсортировать все рёбра по весу за <math>O(N^2 \log N^2) = O(N^2 \log N)</math>, то дальше все рёбра искомого остова можно будет добавить в процессе одного прохода по этому массиву рёбер в порядке возрастания весов - для каждого ребра проверяем, не нарушает ли оно свойство ацикличности <math>T</math> и добавляем его в <math>T</math>, если не нарушает. Для того чтобы быстро проверять свойство принадлежности обоих концов ребра одной из компонент <math>T</math>, используется эффективная структура данных - система непересекающихся множеств<ref>[http://e-maxx.ru/algo/dsu Система непересекающихся множеств]</ref>. Сложность одной такой проверки <math>O(\alpha(N))</math>, где <math>\alpha(N)</math> - обратная функция Аккермана, значение которой не превосходит 4 для <math>N \leqslant 10^{500}</math>. Итоговая сложность такого алгоритма равна сложности сортировки и также составляет <math>O(N^2 \log N)</math>.

'''В алгориме Борувки''', как и в алгоритме Крускала, поддерживается лес <math>T</math>. Изначально лес состоит из <math>N</math> изолированных вершин графа. На каждом шаге путём перебора всех рёбер графа для каждого дерева в <math>T</math> ищется минимальное ребро, ровно один конец которого принадлежит этому дереву. После этого все найденные рёбра добавляются в <math>T</math>. Поскольку после каждой итерации число деревьев в лесе <math>T</math>, исходно равное <math>N</math>, уменьшается не менее чем в 2 раза, таких шагов будет произведено не более <math>\log N</math>, поэтому итоговая сложность алгоритма составляет <math>O(N^2\log N)</math>.

==== Анализ ресурса параллелизма алгоритмов поиска минимального остова ====
Итак, каждый из данных алгоритмов имеет сложность <math>O(N^2\log N)</math>, однако с точки зрения параллельной реализации они различаются. Эффективные реализации алгоритмов Прима и Крускала используют структуры данных, рассчитанные на последовательный характер алгоритма. Так, двоичное дерево поиска, содержащее все рёбра, исходящие из построенного на данный момент остова <math>T</math>, трудно приспособить к распределённым архитектурам. А при работе с полным графом с большим числом вершин хранить его становится практически невозможно. В алгоритме Крускала можно распараллелить этап сортировки рёбер, но на последнем шаге алгоритма необходимо последовательно просмотреть отсортированный массив <math>O(N^2)</math> рёбер, поддерживая СНМ, что сводит на нет параллелизм. Таким образом, для этих двух алгоритмов необходима существенная переработка для получения эффективного параллельного решения <ref>[http://www.cslab.ntua.gr/~knikas/files/papers/mtaap12kruskal.pdf An approach to parallelize Kruskal's algorithm using Helper Threads]</ref>.

На этом фоне выгодно выделяется исторически первый алгоритм Борувки. Он был разработан чешским учёным Отакаром Борувкой в 1926 году для решения задачи построения оптимальной электрической сети в Моравии. Он эффективнее всего использует тат факт, что остовные деревья сперва можно найти для отдельных частей графа, после чего объединить полученные деревья. Далее будем рассматривать именно этот метод для построения минимального остовного дерева в алгоритме кластеризации.

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

=== Макроструктура алгоритма ===
Основными элементами алгоритма, которые дальше будут использоваться, являются следующие процедуры:
* вычисление расстояния <math>\rho(x_i, x_j)</math> между объектами (вершинами полного графа)
* функции для работы с графом - инициализация добавление, удаление ребра
* обход в глубину для выделения компонент связности графа: обход леса производится за <math>O(N)</math> с помощью функции ''обновить_компоненты'', которая возвращает массив ''компонента'', содержащий номер компоненты связности для каждой вершины
* процедура сравнения рёбер: рёбра сравниваются по весу, а при равенстве весов - по идентификатору ребра. Это важная составная часть алгоритма Борувки, поскольку иначе на этапе добавления рёбер могут возникнуть циклы. Простейшим примером является граф из трёх вершин, все попарные расстояния между которыми равны 1: если по ходу работы для первой окажется ближайшей вторая, для второй третья, а для третьей первая, то в граф будет добавлен цикл.
* сортировка массива рёбер по их весу

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

Алгоритм Борувки поиска минимального остовного дерева в полном графе
<source lang="text" line start="1">
Вход: Выборка объектов X размера N
Выход: рёбра минимального остовного дерева T
Алгоритм:
T := пустое множество рёбер
компонента := обновить_компоненты(T)
есть_разные_компоненты := 1
Пока (есть_разные_компоненты равно 1):
есть_разные_компоненты = 0
инициализировать массив D кратчайших рёбер, исходящих из компонент, бесконечно длинными рёбрами
цикл по всем парам вершин (x, y) из X:
если компонента(x) не равно компонента(y):
есть разные компоненты := 1
d := расстояние(x, y)
если (ребро (x, y) < ребро D(компонента(x))):
D(компонента(x)) := (x, y)
если (ребро (x, y) < ребро D(компонента(y))):
D(компонента(y)) := (x, y)
цикл по рёбрам E из D:
добавить E в множество T
компонента := обновить_компоненты(T)
вернуть Т
</source>

Итоговый алгоритм кластеризации:
<source lang="text" line start="1">
Вход: Выборка объектов X, число кластеров K
Выход: метки кластеров для каждого объекта из X
Алгоритм:
T := рёбра минимального остовного дерева для набора объектов X
E := отсортировать рёбра T по убыванию
цикл по первым K рёбрам в E:
удалить ребро из T
компонента := обновить_компоненты(T)
вернуть компонента
</source>

=== Последовательная сложность алгоритма ===
В разделе "Обзор алгоритмов поиска минимального остова" уже было показано, что алгоритм Борувки поиска остова имеет сложность <math>O(N^2 \log N)</math>: поскольку на каждом шаге число компонент уменьшается не менее чем в 2 раза, цикл ''while'' выполнится не более <math>\log N</math> раз. Внутри цикла находятся:
* инициализация массива <math>D</math> кратчайших рёбер, исходящих из компонент связности, бесконечностями - <math>O(N)</math>
* перебор по всем рёбрам полного графа и обновление содержимого ячеек массива <math>D</math> - <math>O(N^2)</math>
* добавление найденных рёбер из массива <math>D</math> в граф <math>T</math> - <math>O(N)</math>
* обновление компонент связности в графе <math>T</math> - <math>O(N)</math>

После поиска остова рёбра остовного дерева сортируются за <math>O(N \log N)</math> операций, за <math>O(N)</math> производится выбрасывание рёбер, за <math>O(N)</math> определяются финальные метки кластеров.

Итоговая сложность <math>O(N^2 \log N)</math> операций. В ходе работы основными являются операции сравнения и обращения в память. Обратим внимание, что "узким местом" алгоритма является перебор по всем рёбрам для нахождения минимальных рёбер, исходящих из каждой компоненты связности остовного леса <math>T</math>.

=== Информационный граф ===
Приведём информационный граф, оставив за скобками детали реализации последних шагов алгоритма - сортировки и выбрасывания рёбер:
[[file:InformationGraph.png|thumb|center|700px|Рис.2. Информационная структура алгоритма кластеризации, основанного на поиске минимального остовного дерева]]

Кратко опишем шаги схемы. Для вычисления массива <math>D</math> необходимо обработать некоторые из перебираемых рёбер (конкретные связи зависят от структуры текущего остовного дерева <math>T</math>), поэтому на этом этапе присутствует нерегулярность по данным; кроме того необходима инициализация массива <math>D</math>. Поскольку на шаге 2 для каждой компоненты необходимо выбирать минимум из набора рёбер, размер которого не ограничен константой, данная операция взятия минимума имеет, вообще говоря, параллельную сложность не менее чем <math>O(\log N)</math>. Операции обновления структуры остовного графа независимы, могут быть распараллелены и склеены в шаг 3. Алгоритмы сортировки и поиска компонент связности теоретически имеют высоту ярусно-параллельной формы <math>O(\log N)</math>. Независимо могут быть выполнены и последние этапы алгоритма, связанные с выбрасыванием рёбер и получением финального ответа, хотя на практике это не так уж важно. Таким образом, поскольку последовательно делается <math>O(\log N)</math> итераций цикла, на каждой из которых высота ярусно параллельной формы имеет порядок <math>O(\log N)</math>, итоговая высота ярусно-параллельной формы (и, соответственно, параллельная сложность алгоритма) - <math>O(\log^2 N)</math>. Ширина ярусно-параллельной формы алгоритма - <math>O(N^2)</math>.

Здесь необходимо отметить, что описанный алгоритм для поиска остовного дерева теоретически не является наиболее оптимальным: в статье <ref>[http://i.cs.hku.hk/~twlam/papers/mst-jacm.ps Concurrent threads and optimal parallel minimum spanning trees algorithm]</ref> приводится алгоритм для графа <math>G = (V, E)</math>, имеющий оптимальную параллельную сложность <math>O(\log N)</math>. Однако, будучи оптимальным в теории, данный алгоритм не практичен - он исходит из числа процессоров порядка <math>O(V + E)</math> (<math>O(N^2)</math> в нашем случае полного графа).

=== Ресурс параллелизма алгоритма ===
Как показал анализ сложности узким местом является нахождение минимальных рёбер, исходящих из каждой компоненты связности остовного леса <math>T</math>. Информационный граф говорит о том, что этот этап можно эффективно распаралелить, так как выбор минимального исходящего ребра для каждой компоненты связности остовного дерева и даже для каждой вершины может исполняться независимо. Процедуры инициализации массива <math>D</math>, добавления найденных рёбер в граф могут быть произведены независимо по элементам. Параллельно может быть проведена и сортировка, и выбрасывание рёбер в конце, хотя это не так принципиально в реальности. Но это позволяет оценить высоту ярусно-параллельной формы и теоретическую параллельную сложность алгоритма.

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

=== Входные и выходные данные алгоритма ===
Входными данными алгоритма является описание выборки из <math>N</math> объектов. В типовом случае каждый из них описывается <math>d</math> координатами, однако может описываться каким-то иным способом, позволяющим находить расстояния между объектами. Также на вход передаётся число искомых кластеров <math>K</math>.

Выходом является массив из <math>N</math> целых чисел от 1 до <math>K</math> - номера кластеров, найденных алгоритмом кластеризации.

=== Свойства алгоритма ===
Известно, что минимальное остовное дерево определено однозначно, если в графе все рёбра различны. Очень важно ввести операцию сравнения рёбер и добиться, чтобы все рёбра были различны. Пример, когда алгоритм Борувки зацикливается из-за этого, приведён выше.

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

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

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
==== Локальность реализации алгоритма ====
===== Структура обращений в память и качественная оценка локальности =====
===== Количественная оценка локальности =====
=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===
==== Масштабируемость алгоритма ====
==== Масштабируемость реализации алгоритма ====
С помощью технологии OpenMP был реализован параллельный алгоритм построения остовного дерева, основанный на алгоритме Борувки. Был распараллелен основной bottleneck алгоритма - поиск минимального ребра, исходящего из кластеров. В качестве данных для экспериментов использовались сгенерированные случайным образом точки на плоскости.

Эксперимент производился на 16-процессорной машине под управлением операционной системы Linux, характеристики процессора: 2,6GHz Intel E3-12xx (Sandy Bridge), 8 instruction per cycle. Опираясь на эти характеристики, получаем, что пиковая теоретическая производительность одного процессора составляет 20,8 Gflops, а вычислительной системы в целом составляет 332,8 GFlops.

Вычислительная сложность каждой задачи оценивалась сверху по формуле: <math>7N^2\log N</math>, где константу 7 определяет число операций с плавающей точкой, необходимое для вычисления квадрата расстояния между двумя точками на плоскости (для выбора минимального ребра в алгоритме Борувки достаточно знать квадрат его длины).

Перебирались следующие параметры запуска, от которых самым существенным образом зависит время работы программы:
* число процессоров: от 2 до 16 с шагом 2
* число кластеризуемых объектов (точек): от 50 тысяч до 150 тысяч с шагом 10 тысяч

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

Ссылка на код реализованного алгоритма и лог эксперимента: https://drive.google.com/open?id=0B4KJzu2I13loaldSbF9XUnJXQ00

Приведём графики времени работы, производительности и эффективности в зависимости от параметров, демонстрирующие свойства параллельной реализации:
[[file:Times_plot.png|thumb|center|500px|Рис.3. График времени работы программы в зависимости от числа процессов и размера задачи]]
Видим, что использование параллелизма позволяет существенно сократить временные затраты, однако в связи с необходимостью синхронизации процессов при переходе к очередной итерации алгоритма эффект параллелизма падает с увеличением числа процессоров. К примеру, на самой большой рассматриваемой задаче (150 тыс. точек) по сравнению с использованием 2 процессоров при использовании 4 процессоров время работы снижается примерно в 1.95 раз (с 469 до 240 секунд), а при использовании всех 16 процессоров - только в 6.8 раз вместо идеальных 8 (с 469 до 69 секунд).

[[file:Perf_plot.png|thumb|center|500px|Рис.4. График производительности программы в зависимости от числа процессов и размера задачи]]
Производительность по числу процессоров напоминает линейную функцию, но при переходе от числа процессоров 14 к 16 видим существенное изменение наклона, которое говорит о том, что этот переход даёт несколько меньший выигрыш по времени по сравнению с предыдущими.

Вывод о понижении эффективности параллелизма с увеличением числа процессоров подтверждает и следующий график:
[[file:Eff_plot.png|thumb|center|500px|Рис.5. График эффективности программы в зависимости от числа процессов и размера задачи]]

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

Масштабируемость программы описывается следующими вычисленными согласно предложенной методике ключевыми показателями:
* минимальная эффективность - 7,32%, максимальная эффективность - 11,75%. Как видим, в архитектуре с общей памятью удалось достичь весьма высоких показателей эффективности
* оценка масштабируемости по числу процессов: -0.00041 - данная цифра говорит о том, что при повышении числа процессов эффективность медленно падает. Это вызвано ростом накладных расходов на синхронизацию результатов, независимо полученных полученных процессорами.
* оценка масштабируемости по размеру задачи: 0.00002 - данная оценка имеет весьма большую дисперсию из-за наблюдаемых перепадов эффективности при изменении размерности задачи, однако в среднем с ростом задачи эффективность очень медленно растёт. Это подтверждает естественное соображение о том, что для больших задач использование параллелизма прирносит наибольшую пользу.
* оценка масштабируемости по двум направлениям: -0.00002 - при увеличении одновременно вычислительной сложности и числа процессоров имеем очень медленное убывание эффективности.

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

Параллельная реализация алгоритма MST:
* C++, MPI: [http://www.boost.org/libs/graph_parallel/doc/html/index.html Parallel Boost Graph Library]; функции <code>[http://www.boost.org/libs/graph_parallel/doc/html/dehne_gotz_min_spanning_tree.html#dense-boruvka-minimum-spanning-tree dense_boruvka_minimum_spanning_tree]</code>, <code>[http://www.boost.org/libs/graph_parallel/doc/html/dehne_gotz_min_spanning_tree.html#boruvka-then-merge boruvka_then_merge]</code>, <code>[http://www.boost.org/libs/graph_parallel/doc/html/dehne_gotz_min_spanning_tree.html#boruvka-mixed-merge boruvka_mixed_merge]</code> сочетают [[алгоритм Борувки]] и [[алгоритм Крускала]].

Последовательные реализации доступны во многих библиотеках:
* [https://networkx.github.io/documentation/networkx-1.9/_modules/networkx/algorithms/mst.html NetworkX MST] - реализация в библиотеке для работы с графами на Python
* [http://www.boost.org/doc/libs/1_38_0/libs/graph/doc/prim_minimum_spanning_tree.html Алгоритм Прима], [http://www.boost.org/doc/libs/1_62_0/libs/graph/doc/kruskal_min_spanning_tree.html Алгоритм Крускала] - C++ реализация в boost
* [http://jgrapht.org/javadoc/org/jgrapht/alg/PrimMinimumSpanningTree.html Алгоритм Прима], [http://jgrapht.org/javadoc/org/jgrapht/alg/KruskalMinimumSpanningTree.html Алгоритм Крускала] - Java реализация в JGraphT

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

<references />

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

Участник:Tereshinvs/MST Clusterization

2016-11-23T10:55:51Z

Zhum:

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

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

Постановка задачи также может различаться характером входных данных:
# Набор признаков <math> V = \left\{ v_1, v_2, \ldots, v_N \right\} </math> в некотором метрическом пространстве с метрикой <math> \rho(x, y) </math>
# Матрица отношений между объектами: симметричная матрица вещественных чисел размером <math> N \times N </math> с неотрицательными элементами с нулевой диагональю.

В данной статье рассматривается постановка с известным количеством кластеров <math> K </math>.

В данной статье рассматривается алгоритм алгоритм кластеризации на основе MST (Minimum spanning tree — минимальное остовное дерево).

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

Общая схема алгоритма:
# Построение минимального остовного дерева одним из известных методов (алгоритмы Крускала, Прима, Борувки и их комбинации; наиболее пригодным для параллельного исполнения считается алгоритм Борувки)
# Удаление <math> K-1 </math> самых длинных рёбер из минимального остовного дерева.

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

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

=== Математическое описание алгоритма ===
Пусть <math>V</math> — множество объектов, <math>Y</math> — множество номеров (имён, меток) кластеров. Задана функция расстояния между объектами <math>\rho(x,y)</math>. Требуется разбить выборку на непересекающиеся подмножества, называемые ''кластерами'', так, чтобы каждый кластер состоял из объектов, близких по метрике <math>\rho</math>, а объекты разных кластеров существенно отличались. При этом каждому объекту <math>v_i\in V</math>
приписывается номер кластера <math>y_i</math>.

''Алгоритм кластеризации'' — это функция <math>a\colon V\to Y</math>, которая любому объекту <math>v\in V</math> ставит в соответствие номер кластера <math>y\in Y</math>. Множество <math>Y</math> в некоторых случаях известно заранее, однако чаще ставится задача определить оптимальное число кластеров, с точки зрения того или иного ''критерия качества'' кластеризации.

В данном случае задачу можно сформулировать так: выбрать пороговое значение веса ребра <math>W</math>, так чтобы объекты, соединённые ребром весом меньше <math>W</math> лежали в одном кластере, а соединённые ребром весом больше <math>W</math> — в разных.

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

=== Макроструктура алгоритма ===
Основной алгоритм можно разделить на следующие части:
# Нахождение для каждой вершины наименьшего ребра, инциндентного ней
# Добавление найденных наименьших вершин в MST
# "Склейка" компонент связности MST
# Нахождение веса <math>W_{K-1}</math> <math>(K-1)</math>-ого наибольшего ребра
# Удаление рёбер весом не меньше чем <math>W_{K-1}</math>.
=== Схема реализации последовательного алгоритма ===
<source lang="text" line start="0" highlight="1,9">
Ввод: граф V

Поместить каждую вершину в отдельное дерево леса T
Пока в T больше одной компоненты связности:
Для каждой компоненты C из T:
S — пустое множество рёбер
Для каждой вершины v в C:
Найти кратчайшее ребро с одним концом v, а другим не из C, и поместить его в S
Добавить кратчайшее ребро из S в T
Объединить компоненты связности
T — MST

Найти W — вес (K-1)-ого максимального ребра в T
Удалить из T рёбра с весом большим или равным W

Пронумеровать компоненты связности

Вывод: номера компонент связности для каждой вершины
</source>

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

# Нахождение ребер наименьшего веса для всех компонент связности требует <math>O(V)</math> операций на каждом шаге, где <math>V</math> — число рёбер в графе.
# Добавление новых рёбер в MST требует <math>O(N)</math> операций за всё время работы алгоритма.
# При использовании структуры данных система непересекающихся множеств с ранговой эвристикой, объединение деревьев требует примерно , где <math>O(N)</math> операций.
# Доказано, что количество шагов алгоритма <math>O(\log N)</math>.

Итого <math>O(V \log N)</math> операций. При использовании триангуляции Делонэ в некоторых случаях <math>V</math> имеет тот же порядок, что и <math>N</math>, поэтому общая сложность <math>O(N \log N)</math>. В общем же случае сложность составляет <math>O(N^2 \log N)</math>

Удаление <math>K-1</math> рёбер можно осуществить за <math>O(N)</math> операций.

Итак, общая сложность алгоритма в общем случае <math>O(N^2 \log N)</math>.

=== Информационный граф ===
[[File:Tereshinvs_mst_scheme.png|frame|center|alt=Информационный граф|Информационный граф алгоритма кластеризации на основе минимального остовного дерева]]

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

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

Узким местом является нахождение k-ой порядковой статистики для выделения кластеров, а так же объединение компонент связности. Но всего объединений компонент связности <math>N-1</math>, поэтому при его реализации с помощью структуры данных система непересекабщихся множеств с ранговой эвристикой общая сложность за всё время работы алгоритма будет близко к <math>O(N)</math>.
=== Входные и выходные данные алгоритма ===
Входными данными являются число <math> N </math> (количество элементов рассматриваемого множества) и матрица вещественных чисел размера <math> N \times N </math> отношений между элементами этого множества. Матрица предполагается симметричной, а её диагональные элементы равными нулю, поэтому её размер можно оценить как <math> \tfrac{N(N-1)}{2} </math>.

Кроме того, имеется натуральное число <math> K \leqslant N </math> — требуемое количество кластеров.

Выходными данными являются <math> N </math> натуральных чисел от <math> 1 </math> до <math> K </math> — номера кластеров, в которые определена каждая вершина. При этом, каждый кластер содержит хотя бы одну вершину.
=== Свойства алгоритма ===
Отрицательной сторой алгоритмов кластеризации, основанных на минимальных остовных деревьях, является их чувствительность к выбросам. С другой стороны, эти алгоритмы способны выделять кластеры произвольной формы, а результат их применения интуитивно понятен.

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

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

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

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

Интересной особенностью использования библиотеки Boost::graph::distributed является возможность задания изначального распределения вершин графа по процессам. К сложностям использования можно отнести нечитаемые сообщения об ошибках инстанцирования шаблонов С++ и отсутствие большого числа примеров использования библиотеки в интернете.

=== Масштабируемость алгоритма и его реализации ===
В этом параграфе описывается масштабируемость параллельной реализации алгоритма из библиотеки Boost::graph::distributed.

С использованием библиотеки Boost::graph::distributed программу можно реализовать следующим образом (указана только часть построения MST):

<source lang="C++" line start="0" highlight="1,9">
#include <boost/graph/use_mpi.hpp>
#include <boost/graph/distributed/mpi_process_group.hpp>
#include <boost/graph/distributed/adjacency_list.hpp>
#include <boost/graph/distributed/dehne_gotz_min_spanning_tree.hpp>
#include <boost/graph/distributed/vertex_list_adaptor.hpp>
#include <boost/graph/metis.hpp>

#include <iostream>
#include <fstream>
#include <vector>

typedef boost::adjacency_list<
boost::listS,
boost::distributedS<
boost::graph::distributed::mpi_process_group,
boost::vecS
>,
boost::undirectedS,
boost::no_property,
boost::property<
boost::edge_weight_t,
float
>
> Graph;

typedef boost::graph_traits<Graph>::edge_descriptor Edge;

int main(int argc, char* argv[])
{
boost::mpi::environment env(argc, argv);

std::ifstream in("big.graph");
boost::graph::metis_reader reader(in);

Graph graph(
reader.begin(), reader.end(),
reader.weight_begin(),
reader.num_vertices()
);

typedef boost::property_map<Graph, boost::edge_weight_t>::type WeightMap;
WeightMap weight_map = boost::get(boost::edge_weight, graph);

std::vector<Edge> mst_edges;

boost::graph::distributed::dense_boruvka_minimum_spanning_tree(
boost::graph::make_vertex_list_adaptor(graph),
weight_map,
std::back_inserter(mst_edges)
);

if (process_id(graph.process_group()) == 0)
std::cout << "Finished" << std::endl;
}
</source>

К сожалению, не удалось запустить программу, использующую данную библиотеку на суперкомпьютере IBM BlueGene/P, поэтому замеры производительности производились на компьютере с процессором Intel Core i5 4210U (два ядра и четыре потока, тактовая частота 1.7ГГц, до 2.7ГГц в режиме Turbo Boost), 6GB оперативной памяти DDR3, жёстким диском с частотой вращения шпинделя 5400 об/мин под управлением Windows 10 64-bit с использованием Windows Subsystem for Linux.

Замеры производились только для построения минимального остовного дерева для полного графа (вершины — объекты, рёбра с весами — отношения), так как это является вычислительным ядром алгоритма.

[[File:boost_mst_time.png|frame|center|alt=Время работы|Время работы алгоритма построения MST на полном графе из 5000 вершин, синем показана полученное время работы в секундах, зелёным — ожидаемое относительно увеличения количества процессором]]

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

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

=== Существующие реализации алгоритма ===
Библиотека шаблонов для С++ Boost предлагает прямую параллельную реализацию алгоритма Борувки в компоненте graph/distributed. Кроме этого, в ней имеются реализации других алгоритмов построения MST, а также много других параллельных алгоритмов на графах. Библиотека основана на технологии MPI. IBM предоставил патч для Boost 1.47.0 для её использования с компиляторами IBM CL C/C++.

Кроме этой библиотеки не существует распространённой библиотеки, реализующей параллельный алгоритм построения минимального остовного дерева. Но имеется достаточно большое количество библиотек, реализующих однопоточное построение MST:
* JGraphT для Java
* SciPy MST
* множество любительских реализаций, который можно легко найти в интернете по запросу "mst algorithm".

== Литература ==
# Нейский И.М. Классификация и сравнение методов кластеризации, http://it-claim.ru/Persons/Neyskiy/Article2_Neiskiy.pdf
# Minimum spanning tree, https://en.wikipedia.org/wiki/Minimum_spanning_tree
# Алгоритм Борувки, https://en.wikipedia.org/wiki/Bor%C5%AFvka%27s_algorithm
# Euclidean minimum spanning tree, https://en.wikipedia.org/wiki/Euclidean_minimum_spanning_tree
# Система непересекающихся множеств, http://e-maxx.ru/algo/dsu
# Boost Library, http://www.boost.org/
# Параллельное построение MST в библиотеке Boost, http://www.boost.org/doc/libs/1_55_0/libs/graph_parallel/doc/html/dehne_gotz_min_spanning_tree.html#id14
# Патч Boost 1.47.0 для IBM CL C/C++, http://www-01.ibm.com/support/docview.wss?uid=swg27027469

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

2016-11-23T10:55:34Z

Zhum:

п. 2.4

* нет пояснений к графику

Участник:Guryanovak/Алгоритм кластеризации, основанный на минимальном остовном дереве

2016-11-23T10:44:10Z

Zhum:

Авторы описания: [[Участник:guryanovak|Гурьянов Алексей Константинович]], [[Участник:Валерия Кибитова|Кибитова Валерия Николаевна]]

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

{{algorithm
| name = Алгоритм кластеризации, основанный на минимальном остовном дереве
| serial_complexity = <math>O(N^2 \log_2 N)</math>
| input_data = <math> O(Nm) </math>
| output_data = <math> O(N) </math>
}}

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

== Общее описание алгоритма ==
Данный алгоритм решает задачу кластеризации. Кластеризация – это задача разбиения множества объектов на не пересекающиеся подмножества, называемые кластерами таким образом, что объекты в одном кластере были более похожи (в каком-либо смысле) друг на друга, а объекты в разных кластерах существенно отличались.

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

Проблема нахождения минимального остовного дерева, а также ее решение было предложено Борувка в 1926 году. Идея использовать минимальное остовное дерево для кластеризации впервые была предложена Zahn в 1971<ref>Zahn C. T. Graph-theoretical methods for detecting and describing gestalt clusters //IEEE Transactions on computers. – 1971. – Т. 100. – №. 1. – С. 68-86.</ref>, в последующие годы данная идея развивалась такими учеными как: Asano, Bhattacharya, Keil, и Yao<ref>Asano T. et al. Clustering algorithms based on minimum and maximum spanning trees //Proceedings of the fourth annual symposium on Computational geometry. – ACM, 1988. – С. 252-257.</ref>, Avis<ref>Avis D. Diameter partitioning //Discrete & Computational Geometry. – 1986. – Т. 1. – №. 3. – С. 265-276.</ref>, Eldershaw и Hegland<ref>Eldershaw C., Hegland M. Cluster analysis using triangulation //Computational Techniques and Applications. – 1997. – С. 201-208.</ref>, Paivinen и другими<ref>Grygorash O., Zhou Y., Jorgensen Z. Minimum spanning tree based clustering algorithms //2006 18th IEEE International Conference on Tools with Artificial Intelligence (ICTAI'06). – IEEE, 2006. – С. 73-81.</ref>.

Основная идея алгоритма состоит из следующих шагов:

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

2. Построение минимального остовного дерева.
Для этого можно использовать следующие алгоритмы:
*алгоритм Крускала;
*алгоритм Прима;
*алгоритм Борувки.

3. Выделение кластеров.
В минимальном остовном дереве, выбирается <math>k-1</math> ребро (где <math>k</math> – это заранее определенное число кластеров), имеющие наибольшой вес. Выбранные ребра удаляются. Оставшиеся k компонент связности считаются кластерами.

В данной статье алгоритм будет описываться с использованием алгоритма Борувки. Подробное описание которого можно найти пройдя по ссылке [[https://algowiki-project.org/ru/Алгоритм_Борувки Алгоритм Борувки]]

Общая идея его состоит в следующем:
#Изначально каждая вершина графа — тривиальное дерево, а ребра не принадлежат никакому дереву.
#Для каждого дерева найдем минимальное по весу инцидентное ему ребро. Добавим все такие ребра.
#Повторяем шаг 2 пока в графе не останется только одно дерево.

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

На вход алгоритму подается набор <math>N</math> векторов размерности <math>m</math> : <math>(a_{i,1}, a_{i,2}, ..., a_{i,m})</math>, где <math> a_j \in \mathbb {R} \quad \forall j \in [1,m], i \in [1..N] </math> и количество кластеров <math>K</math>, на которые необходимо разбить множество точек.

На выход алгоритм должен вывести <math>N</math> чисел от <math>1</math> до <math>K</math>, показывающих принадлежность входных векторов кластерам.

=== Основные обозначения ===

* <math>E</math> - множество рёбер.
* <math>V</math> - множество вершин.
* <math>G = (V,E) </math> - неориентированный граф, заданный множеством вершин <math>V</math> и множеством рёбер <math>E</math>
* <math>MST(G)</math> (Minimum Spanning Tree) - минимальное остовное дерево графа <math></math>. Остовное дерево — ациклический связный подграф данного связного неориентированного графа, в который входят все его вершины. Минимальное остовное дерево в связанном взвешенном неориентированном графе — это остовное дерево этого графа, имеющее минимальный возможный вес, где под весом дерева понимается сумма весов входящих в него рёбер.

=== Функция веса ===

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

В данной статье будет рассматриваться евклидова метрика:
* <math> | x , y | = \sqrt{\sum_i^m (x_i - y_i)^2} </math>

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

Работу алгоритма можно разделить на три блока:
*1: Вычисление расстояний между вершинами и заполнение данных о компонентах связности
*2: Построение минимального основного дерева
*3: Разделение на K кластеров

Из них основное время работы алгоритма занимают блоки 1 и 2.

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

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

Для описания алгоритма вводятся следующие макрооперации:
*1: getDistance – находит расстояние между двумя вершинами графа как расстояние между соответствующими им точками пространства. (Сложность – <math>O(m)</math>)
*2: initializeComponents – инициализирует состояние класса Components информацией о вершинах и ребрах. В каждую исходную компоненту связности входит одна вершина. (Сложность – <math>O(N^2)</math>)
*3: findMinimalOutgoingEdge – находит ребро c наименьшей длиной, исходящее из заданной компоненты связности. (Cложность – <math>O(N)</math>)
*4: findComp – возвращает индекс компоненты связности в которой находится вершина (Cложность – <math>O(1)</math>)
*5: connectComponentsWithEdge – соединяет две компоненты связности, связанные поданным на вход ребром. Объединение компонент включает в себя замену ребер инцидентности новой компоненты на минимальные ребра из пары объединяемых компонент. (Сложность – <math>O(N)</math>)

Макрооперации 2-5 относятся к последовательной реализации [[Алгоритм Борувки|алгоритма Борувки]], который был выбран как основа вычислительного ядра алгоритма.

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

Схема работы алгоритма была создана с учетом последующей параллельной реализации,<ref>Chung S., Condon A. Parallel implementation of Bouvka's minimum spanning tree algorithm //Parallel Processing Symposium, 1996., Proceedings of IPPS'96, The 10th International. – IEEE, 1996. – С. 302-308.</ref>

<source lang="cpp">
int N; // Размер входных данных
int number_of_clusters; // Число кластеров
int size = N*N; // Размер матрицы инцидентности
Node nodes[N]; // Вершины(точки), заданные начальными условиями
Edge edges[size]; // Все расстояния между вершинами
vector<Edge> tree; // Рёбра минимального остовного дерева
Components comps; // Структура компонент связности
read_data(&nodes, file_name); // Считывание начальных данных

//----------------Вычисление расстояний между вершинами----------------//
for(int i = 0; i < N-1; i++) {
for(int j = i+1; j < N; j++) {
double distance = getDistance(node[i], node[j]); // Вычисление расстояний между вершинами
edges[i*N + j] = Edge(i,j,distance); // Запись значения расстояния в массив
edges[j*N + i] = Edge(i,j,distance); // Запись значения расстояния в массив
}
}

//----------------Заполнение данных о компонентах связности--------------//
initializeComponents(&comps, nodes, edges);

//----------------Построение минимального основного дерева--------------//
while(comps.size > 1) {
vector<edges> mstedges;
for component in comps {
edge e = findMinimalOutgoingEdge(component, comps, edges) // Нахождение минимального ребра инцидентного данной компоненте
mstedges.add(e)
}
for mstedge in mstedges {
if (findComp(comps, mstedge.first) != findComp(comps, mstedge.second)) {
connectComponentsWithEdge(comps, mstedge) // Объединение двух компонент
tree.add(mstedge) // Добавление ребра в минимальное основное дерево
}
}
}

//-----------------------Разделение на K кластеров--------------------------//
sort(tree)
for(int i = tree.size() - 1; i > tree.size() - 1 - number_of_clusters; i--) {
remove_edge(tree, i); // Удаление самых длинных рёбер из MST - формирование кластеров
}
write_data(tree); // Запись выходных данных
</source>

== Последовательная сложность алгоритма ==
Среди выделенных в описании частей алгоритма, самую большую сложность для оценивания временной сложности вызывает часть 3, являющаяся реализацией алгоритма Борувки. Однако если заметить, что после выполнения каждого тела внешнего цикла количество компонент связности будет уменьшаться как минимум вдвое (так как одно ребро в списке ребер минимального основного дерева может повториться максимум двое), то можно сделать вывод, что сложность в худшем случае этого блока алгоритма является <math> O (N^2 \log_2 N) </math>.

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

<math> TC(N, m) = O(N^2m) + O(N^2) + O(N^2 \log_2 N) + O(N \log_2 N) = O(N^2 (m + \log_2 N)) </math>

Если посчитать размерность пространства входных точек за константу при расчете сложности, то временная сложность выразится как

<math> TC(N, m) = O(N^2 \log_2 N) </math>

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

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

[[Файл:InformationGraph-2-8.png|frame|center|alt=Алгоритм| Информационный граф параллельного алгоритма кластеризации на основе алгоритма Борувки]]

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

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

Основная особенность алгоритма построения минимального основного дерева Борувки состоит в том, что основной блок этого алгоритма, нахождения минимального ребра, инцидентного заданной вершине, можно проводить независимо. Это позволяет провести вычисления в ярусе, ответственном за поиск кратчайших ребер за <math>O(1)</math> времени при наличии как минимум <math>N^3</math> процессоров. Процесс обновления информации о компонентах связности, который заключается в обновлении индексов кластеров вершин и в обновлении расстояний между кластерами, можно представить в виде независимой последовательности операций взятия минимума и операций присваивания в количестве <math>O(N)</math> штук (количество компонент связности), что позволит выполнить ярус, ответственный за обновление структуры компонент связности за <math>O(1)</math> при наличие как минимум <math>2N</math> процессоров. Это значит, что каждый ярус будет выполняться за <math> O(1) </math> времени, и аналогично последовательному алгоритму Борувки, после выполнения 2 ярусов количество компонент связности уменьшится минимум вдвое, что гарантирует то, что за время выполнения алгоритма повторится не более чем <math> 4 * \log_2 N </math> ярусов. Учитывая ярусы, посвященные считыванию ввода, вычислению расстояний между точками пространства, удалению <math>K-1</math> ребер из минимального опорного дерева и выводу ответа, итоговую параллельная сложность алгоритма можно оценить как <math> 2 * \log_2 N + 5</math>.

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

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

=== Входные данные алгоритма ===
На вход алгоритму подается набор <math>N</math> векторов размерности <math>m</math> : <math>(a_{i,1}, a_{i,2}, ..., a_{i,m})</math>, где <math> a_j \in \mathbb {R} \quad \forall j \in [1,m], i \in [1..N] </math> и количество кластеров <math>K</math>, на которые необходимо разбить множество точек. Общий объем входных данных можно оценить как <math>O(Nm)</math>.

Если оценивать размерность пространства входных точек константой, то объем входных данных можно оценить как <math>O(N)</math>.

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

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

Соотношение последовательной и параллельной сложности алгоритма равно <math> \frac{N^2 \log_2 N} {\log_2 N} = N^2 </math>.

Вычислительную мощность алгоритма можно оценить как <math> \frac {N^2 \log_2 N} {N} = N \log_2 N</math>.

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

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

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

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

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

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

== Масштабируемость алгоритма и его реализации ==
Авторами данной статьи было проведено исследование масштабируемости параллельной реализации алгоритма кластеризации, основанном на минимальном остовном дереве. Исследование алгоритма проводилось на суперкомпьютере "Ломоносов" [http://parallel.ru/cluster суперкомпьютерного комплекса Московского университета]. Параллельная реализация была написана с помощью OpenMP. Распараллеливание проводилось по числу объектов кластеризации, поэтому исследование масштабируемости проводилось для числа объектов кластеризации. Алгоритм исследовался на наборе данных, который был сгенерирован при помощи функции [http://scikit-learn.org/stable/modules/generated/sklearn.datasets.make_blobs.html make_blobs (sklearn)] (количество признаков – 2, количество кластеров – 2).

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

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

На графиках, представленных ниже, отображена производительность и эффективность распараллеливания алгоритма кластеризации, основанного на минимальном остовном дереве, в зависимости от изменяемых параметров запуска.
[[File:Execution_GK_MST.png|800px|thumb|center|Рис.1. Изменение производительности в зависимости от числа процессов и числа входных объектов]]
[[File:Efficiency_MST_GK.png|800px|thumb|center|Рис.2. Изменение эффективности распараллеливания в зависимости от числа процессов и числа входных объектов]]

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

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

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

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

[https://bitbucket.org/GuryanovKibitova/mstclusterization/src/ccaffad7780e3aee9645845539e6e1a311295208?at=master Параллельная реализация на языке C++ (+OpenMP)]

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

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

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

Существующих реализаций алгоритма кластеризации в настоящий момент немного. Ниже приводится список некоторых из них:
*[https://github.com/jakevdp/mst_clustering MST Clustering Python]
Однако существует множество реализаций алгоритма поиска минимального остовного дерева, на основе которых можно реализовать алгоритм кластеризации.
*[https://github.com/umarali/boruvka-mst-parallel Parallel Implementation of Borůvka's MST Algorithm ]
*[http://www.mlpack.org/docs/mlpack-2.0.2/doxygen.php?doc=namespacemlpack_1_1emst.html С++ mlpack MST Algorithm ]
*[https://github.com/nastra/algorithms-java Java Graph Algorithms]
*[http://jgrapht.org/javadoc/org/jgrapht/alg/KruskalMinimumSpanningTree.html Kruskal Java MST Algorithm ]
*[http://jgrapht.org/javadoc/org/jgrapht/alg/PrimMinimumSpanningTree.html Prim Java MST Algorithm ]
*[https://github.com/dineshappavoo/GraphMinimumSpanningTree Java Graph Minimum Spanning Tree ]
*[https://pypi.python.org/pypi/PyAlgDat Python PyAlgDat ]
*[https://networkx.github.io/documentation/networkx-1.10/reference/algorithms.mst.html Python NetworkX Minimum Spanning Tree]
*[http://www.boost.org/doc/libs/1_53_0/libs/graph_parallel/doc/html/dehne_gotz_min_spanning_tree.html C++ Boost Minimum Spanning Tree]

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

<references \>

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

2016-11-23T10:43:55Z

Zhum:

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

Ничего не понятно - увеличиваем число процессоров и эффективность ПАДАЕТ. Но медленнее... Медленнее чего? В каких случаях она ещё падает по сравнению с этим?

Переформулируйте мысль.

Участник:Бротиковская Данута/Алгоритм k-means

2016-11-23T10:19:09Z

Zhum:

{{Assignment|Zhum}}

{{algorithm
| name = Алгоритм k средних (k means)
| serial_complexity = <math>O(\Tau*k*d*n)</math>
| input_data = <math> d*n </math>
| output_data = <math> n </math>
}}

Авторы страницы [[Участник:Бротиковская Данута|Данута Бротиковская]] и [[Участник:DennZo1993|Денис Зобнин]].

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

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

=== Общее описание алгоритма ===
Алгоритм k средних (k means) – неиерархический<ref>"https://ru.wikipedia.org/wiki/Иерархическая_кластеризация"</ref>, итерационный метод кластеризации<ref>"https://ru.wikipedia.org/wiki/Кластерный_анализ"</ref>, получивший большую популярность благодаря своей простоте, наглядности реализации и достаточно высокому качеству работы. Был изобретен в 1950-х годах математиком Гуго Штейнгаузом<ref>Steinhaus, Hugo. "Sur la division des corp materiels en parties." Bull. Acad. Polon. Sci 1.804 (1956): 801.</ref> и почти одновременно Стюартом Ллойдом<ref>Lloyd, S. P. "Least square quantization in PCM. Bell Telephone Laboratories Paper. Published in journal much later: Lloyd, SP: Least squares quantization in PCM." IEEE Trans. Inform. Theor.(1957/1982).</ref>. Особую популярность приобрел после публикации работы МакКуина<ref>MacQueen, James. "Some methods for classification and analysis of multivariate observations." Proceedings of the fifth Berkeley symposium on mathematical statistics and probability. Vol. 1. No. 14. 1967.</ref> в 1967.

Алгоритм представляет собой версию EM-алгоритма<ref>"https://ru.wikipedia.org/wiki/EM-алгоритм"</ref>, применяемого также для разделения смеси гауссиан. Основная идея k means заключается в том, что данные произвольно разбиваются на кластеры, после чего итеративно перевычисляется центр масс для каждого кластера, полученного на предыдущем шаге, затем векторы разбиваются на кластеры вновь в соответствии с тем, какой из новых центров оказался ближе по выбранной метрике.

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

=== Математическое описание алгоритма ===
Дано:
* набор из <math>n</math> наблюдений <math>X=\{\mathbf{x}_1, \mathbf{x}_2, ..., \mathbf{x}_n\}, \mathbf{x}_i \in \mathbb{R}^d, i=\overline{1, n}</math>;
* <math>k</math> - требуемое число кластеров, <math>k \in \mathbb{N}, k \leq n</math>.

Требуется:

Разделить множество наблюдений <math>X</math> на <math>k</math> кластеров <math>S_1, S_2, ..., S_k</math>:
* <math>S_i \cap S_j= \varnothing, \quad i \ne j</math>

* <math>\bigcup_{i=1}^{k} S_i = X</math>

Действие алгоритма:
Алгоритм k means разбивает набор <math>X</math> на <math>k</math> наборов <math>S_1, S_2, ..., S_k,</math> таким образом, чтобы минимизировать сумму квадратов расстояний от каждой точки кластера до его центра (центр масс кластера). Введем обозначение, <math>S=\{S_1, S_2, ..., S_k\}</math>. Тогда действие алгоритма k means равносильно поиску:
<table style="width:100%">
<tr>
<td align="center" width="90%"><math>\arg\min_{S} \sum\limits_{i=1}^k \sum\limits_{\mathbf{x} \in S_i} \rho(\mathbf{x}, \mathbf{\mu}_i )^2,</math></td>
<td align="right"><math>(1)</math></td>
</tr>
</table>
где <math>\mathbf{\mu}_i</math> – центры кластеров, <math>i=\overline{1,k}, \quad \rho(\mathbf{x}, \mathbf{\mu}_i)</math> – функция расстояния между <math>\mathbf{x}</math> и <math>\mu_i</math>

Шаги алгоритма: 
<ol>
<li>
Начальный шаг: инициализация кластеров
Выбирается произвольное множество точек <math>\mu_i, i=\overline{1,k}</math>, рассматриваемых как начальные центры кластеров: <math>\mu_i^{(0)} = \mu_i, \quad i=\overline{1, k}</math>
</li>
<li>
Распределение векторов по кластерам
Шаг <math>t: \forall \mathbf{x}_i \in X, i=\overline{1,n}: \mathbf{x}_i \in S_j \iff j=\arg\min_{k}\rho(\mathbf{x}_i,\mathbf{\mu}_k^{(t-1)})^2</math>
</li>
<li>
Пересчет центров кластеров
Шаг <math>t: \forall i=\overline{1,k}: \mu_i^{(t)} = \cfrac{1}{|S_i|}\sum_{\mathbf{x}\in S_i}\mathbf{x}</math>
</li>
<li>
Проверка условия останова:

'''if''' <math>\exist i\in \overline{1,k}: \mu_i^{(t)} \ne \mu_i^{(t-1)}</math> '''then'''
t = t + 1;
goto 2;
'''else'''
'''stop'''
</li>
</ol>

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

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


Распределение векторов по кластерам предполагает вычисление расстояний между каждым вектором <math>\mathbf{x}_i \in X, i= \overline{1,n}</math> и центрами кластера <math>\mathbf{\mu}_j, j= \overline{1,k}</math>. Таким образом, данный шаг предполагает <math>k*n</math> вычислений расстояний между d-мерными векторами.


Пересчет центров кластеров предполагает <math>k</math> вычислений центров масс <math>\mathbf{\mu}_i</math> множеств <math>S_i, i=\overline{1,k}</math> представленных выражением в шаге 3 представленного выше алгоритма.


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

Инициализация центров масс <math>\mu_1, ..., \mu_k</math>.

Наиболее распространенными являются следующие стратегии:
<ul>
<li>
Метод Forgy В качестве начальных значений <math>\mu_1, ..., \mu_k</math> берутся случайно выбранные векторы.
</li>
<li>
Метод случайно разделения (Random Partitioning) Для каждого вектора <math>\mathbf{x}_i \in X, i=\overline{1, n}</math> выбирается случайным образом кластер <math>S_1, ..., S_k</math>, после чего для каждого полученного кластера вычисляются значения <math>\mu_1, ..., \mu_k</math>.
</li>
</ul>

Распределение векторов по кластерам

Для этого шага алгоритма между векторами <math>\mathbf{x}_i \in X, i=\overline{1, n}</math> и центрами кластеров <math>\mu_1, ..., \mu_k</math> вычисляются расстояния по формуле (как правило, используется Евлидово расстояние):
<table style="width:100%">
<tr>
<td align="center" width="90%"><math> \mathbf{v}_1, \mathbf{v}_2 \in \mathbb{R}^d, \quad \rho(\mathbf{v}_1, \mathbf{v}_2) = \lVert \mathbf{v}_1- \mathbf{v}_2 \rVert= \sqrt{\sum_{i=1}^{d}(\mathbf{v}_{1,i} - \mathbf{v}_{2,i})^2}</math></td>
<td align="right"><math>(2)</math></td>
</tr>
</table>

Пересчет центров кластеров

Для этого шага алгоритма производится пересчет центров кластера по формуле вычисления центра масс:
<table style="width:100%">
<tr>
<td align="center" width="90%"><math> \mu = \cfrac{1}{|S|}\sum_{\mathbf{x}\in S}\mathbf{x}</math></td>
<td align="right"><math>(3)</math></td>
</tr>
</table>

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

'''algorithm''' k-means '''is'''
'''1.''' Инициализировать центры кластеров <math>\mathbf{\mu}_i^{(1)}, i=\overline{1,k}</math>
'''2.''' <math>t \leftarrow 1</math>
'''3.''' '''Распределение по кластерам''' 
<math>S_i^{(t)}=\{\mathbf{x}_p: \lVert\mathbf{x}_p-\mathbf{\mu}_i^{(t)}\rVert^2 \leq \lVert\mathbf{x}_p-\mathbf{\mu}_j^{(t)}\rVert^2 \quad \forall j=\overline{1,k}\},</math> 
где каждый вектор <math>\mathbf{x}_p</math> соотносится единственному кластеру <math>S^{(t)}</math>
'''4.''' '''Обновление центров кластеров''' 
<math>\mathbf{\mu}_i^{(t+1)} = \frac{1}{|S^{(t)}_i|} \sum_{\mathbf{x}_j \in S^{(t)}_i} \mathbf{x}_j </math> 
'''5.''' '''if''' <math>\exist i \in \overline{1,k}: \mathbf{\mu}_i^{(t+1)} \ne \mathbf{\mu}_i^{(t)}</math> '''then'''
t = t + 1;
goto '''3''';
'''else'''
'''stop'''

=== Последовательная сложность алгоритма===
<div style="padding-bottom: 20px">
Обозначим <math>\Theta_{centroid}^{d, m}</math> временную сложность вычисления центорида кластера, число элементов которого равна <math>m</math>, в d-мерном пространстве.
Аналогично <math>\Theta_{distance}^d</math> – временная сложность вычисления расстояния между двумя d-мерными векторами.
</div>
<div style="padding-bottom: 20px">
Сложность шага инициализации <math>k</math> кластеров мощности <math>m</math> в d-мерном пространстве – <math>\Theta_{init}^{k, d, m}</math>
<ul>
<li>Стратерия Forgy: вычисления не требуются, <math>\Theta_{init}^{k, d, m} = 0</math></li>
<li>Стратегия случайного разбиения: вычисление центров <math>k</math> кластеров, <math>\Theta_{init}^{k, d, m} = k*\Theta_{centroid}^{d, m}, m \le n</math></li>
</ul>
</div>
<div style="padding-bottom: 20px">
Cложность шага распределения d мерных векторов по <math>k</math> кластерам – <math>\Theta_{distribute}^{k, d}</math>

На этом шаге для каждого вектора <math>\mathbf{x}_i \in X, i=\overline{1, n}</math> вычисляется k расстояний до центров кластеров <math>\mathbf{\mu}_1, ...\mathbf{\mu}_k</math>


<math>\Theta_{distribute}^{k, d} = n*k*\Theta_{distance}^d</math>

</div>
<div style="padding-bottom: 20px">

Сложность шага пересчета центров <math>k</math> кластеров размера <math>m</math> в d-мерном пространстве – <math>\Theta_{recenter}^{k, d, m}</math>

На этом шаге вычисляется <math>k</math> центров кластеров <math>\mathbf{\mu}_1, ...\mathbf{\mu}_k</math>
<math>\Theta_{recenter}^{k, d, m} = k*\Theta_{centroid}^{d, m}</math> 
</div>
<div style="padding-bottom: 20px">
Рассчитаем <math>\Theta_{centroid}^{d, m}</math> для кластера, число элементов которого равно <math>m</math>
<math>\Theta_{centroid}^{d, m}</math> = <math>m * d</math> сложений + <math>d</math> делений 
</div>
<div style="padding-bottom: 20px">
Рассчитаем <math>\Theta_{distance}^d</math> в соответствие с формулой <math>(2)</math>
<math>\Theta_{distance}^d</math> = <math>d</math> вычитаний + <math>d</math> умножений + <math>(d-1)</math> сложение
</div>
<div style="padding-bottom: 20px">
Предположим, что алгоритм сошелся за <math>\Tau</math> итераций, тогда временная сложность алгоритма <math>\Theta_{k-means}^{d, n}</math>
<math>\Theta_{k-means}^{d, n} \le \Theta_{init}^{k, d, n} + \Tau*(\Theta_{distribute}^{k, d} + \Theta_{recenter}^{k, d, n})</math>
</div>
<div style="padding-bottom: 5px">
Операции сложения/вычитания:
<math>\Theta_{k-means}^{d, n} \le k*n*d+ \Tau*(k*n*(2d-1) + k*n*d) = k*n*d+ \Tau*(k*n*(3d-1)) \thicksim O(\Tau*k*d*n)</math>
</div>
<div style="padding-bottom: 20px">
Операции умножения/деления:
<math>\Theta_{k-means}^{d, n} \le k*d + \Tau*(k*n*d + k*d) = k*d + \Tau * k*d*(n+1) \thicksim O(\Tau*k*d*n) </math>
</div>
<div style="padding-bottom: 20px">
Получаем, что временная сложность алгоритма k means кластеризации <math>n</math> d-мерных векторов на <math>k</math> кластеров за <math>\Tau</math> итераций:
<math> \Theta_{k-means}^{d, n} \thicksim O(\Tau*k*d*n) </math>
</div>

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

Рассмотрим информационный граф алгоритма. Алгоритм k means начинается с этапа инициализации, после которого следуют итерации, на каждой из которых выполняется два последовательных шага (см. [[#Схема реализации последовательного алгоритма|"Схема реализации последовательного алгоритма"]]):
* распределение векторов по кластерам
* перерасчет центров кластеров

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

Распределение векторов по кластерам
Информационный граф шага распределения векторов по кластерам представлен на ''рисунке 1''. Исходами данного графа является исходные векторы <math>\mathbf{x}_1, ..., \mathbf{x}_n</math>, а также центры кластеров <math>\mathbf{\mu}_1, ... \mathbf{\mu}_k</math>, вычисленные ранее (на шаге инициализации, если рассматривается первая итерация алгоритма, или на шаге пересчета центров кластеров предыдущей итерации в противном случае). Каждая пара векторов данных <math>\mathbf{x}_i, i=\overline{1,n}</math> и центров кластера <math>\mathbf{\mu}_j, j=\overline{1, k}</math> : (<math>\mathbf{x}_i</math>, <math>\mathbf{\mu}_j</math>) подаются на независимые узлы "d" вычисления расстояния между векторами (более подробная схема вычисления расстояния представлена далее, ''рисунок 2''). Далее узлы вычисления расстояния "d", соответствующие одному и тому же исходному вектору <math>\mathbf{x}_i</math> передаются на один узел "m", где далее происходит вычисление новой метки кластера для каждого вектора <math>\mathbf{x}_i</math> (берется кластер с минимальным результатом вычисления расстояния). На выходе графа выдаются метки кластеров , <math>L_1, ..., L_n</math>, такие что <math>\forall \mathbf{x}_i, i=\overline{1, n}, \mathbf{x}_i \in S_j \Leftrightarrow L_i = j</math>.

[[file:Clusterization.png|thumb|center|800px|Рис. 1. Схема распределения векторов по кластерам. ''d'' – вычисление расстояния между векторами; ''m'' – вычисление минимума.]]

Вычисление расстояния между векторами
Подробная схема вычисления расстояния между векторами <math>\mathbf{x}_i, \mathbf{\mu}_j</math> представлена на ''рисунке 2''. Как показано на графе, узел вычисления расстояния между векторами "d" состоит из шага взятия разности между векторами (узел "<math>-</math>") и взятия нормы получившегося вектора разности (узел "<math>||\cdot||^2</math>"). Более подробно, вычисление расстояния между векторами <math>\mathbf{x}_i = {x_{i1,}, ...,{x_{in}}}, \mathbf{\mu}_j = {\mu_{j1}, ...,\mu_{jn}}</math> может быть представлено как вычисление разности между каждой парой компонент <math>(x_{iz}, \mu_{jz}), z=\overline{1, d}</math> (узел "<math>-</math>"), далее возведение в квадрат для каждого узла "<math>-</math>" (узел "<math>()^2</math>") и суммирования выходов всех узлов "<math>()^2</math>" (узел "<math>+</math>").

[[file:dist_calc.png|thumb|center|800px|Рис. 2. Схема вычисления расстояния между вектором и центром кластера.]]

Пересчет центров кластеров
Информационный граф шага пересчета центров кластеров представлен на ''рисунке 3''. Исходами данного графа является исходные векторы <math>\mathbf{x}_1, ..., \mathbf{x}_n</math>, а также им соответствующие метки кластера, <math>L_1, ..., L_n</math>, такие что <math>\forall x_i, i=\overline{1, n}, \mathbf{x}_i \in S_j \Leftrightarrow L_i = j</math>, вычисленные на этапе распределения векторов по кластерам. Все векторы <math>\mathbf{x}_1, ..., \mathbf{x}_n</math> подаются в узлы <math>+_1, ...+_k</math>, каждый узел <math>+_m, m = \overline{1,k}</math> соответствует операции сложения векторов кластера с номером <math>m</math>. Метки кластера <math>L_1, ..., L_n</math> также совместно передаются на узлы <math>S_m, m = \overline{1,k}</math>, на каждом из которых вычисляется количество векторов в соответствующем кластере (количество меток с соответствующим значением). Далее каждая пара выходов узлов <math>+_m</math> и <math>S_m</math> подается на узел "<math>/</math>", где производится деление суммы векторов кластера на количество элементов в нем. Значения, вычисленные на узлах "<math>/</math>", присваиваются новым центрам кластеров (выходные значения графа).

[[file:Recluster.png|thumb|center|800px|Рис. 3. Схема пересчета центров кластеров]]

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

Работа алгоритма состоит из <math>\Tau</math> итераций, в каждой из которых происходит распределение d-мерных векторов по <math>k</math> кластерам, а также пересчет центров кластеров в d-мерном пространстве. В шаге распределения d-мерных векторов по <math>k</math> кластерам расстояния между вектором и центрами кластеров вычисляются независимо (отсутствуют информационные зависимости). Центры масс кластеров также пересчитываются независимо друг от друга. Таким образом, имеет место [[глоссарий#Массовый параллелизм|''массовый параллелизм'']]. Вычислим параллельную сложность <math>\Psi_*</math> каждого из шагов, а также параллельную сложность всего алгоритма, <math>\Psi_{k-means}</math>. Будем исходить из предположения, что может быть использовано любое необходимое число потоков.


Распределение d-мерных векторов по <math>k</math> кластерам

Поскольку на данном шаге для каждой пары векторов <math>\mathbf{x}_i, i=\overline{1,n}</math> и <math>\mathbf{\mu}_j, j=\overline{1,k}</math> операции вычисления расстояния не зависят друг от друга, они могут выполняться параллельно. Тогда, разделив все вычисление расстояний на <math>n</math> потоков, получим, что в каждом потоке будет выполняться только одна операция вычисления расстояния между векторами размерности d. При этом каждому вычислительному потоку передаются координаты центров всех кластеров <math>\mathbf{\mu}_1, ..., \mathbf{\mu}_k</math>. Таким образом, параллельная сложность данного шага определяется сложностью параллельной операции вычисления расстояния между d-мерными векторами, <math>\Psi_{distance}^d</math> и сложностью определения наиболее близкого кластера (паралельное взятие минимума по расстояниям), <math>\Psi_{min}^k</math>. Для оценки <math>\Psi_{distance}^d</math> воспользуемся [[Нахождение_частных_сумм_элементов_массива_сдваиванием | параллельной реализацией нахождения частичной суммы элементов массива путем сдваивания]]. Аналогично, <math>\Psi_{min}^k = log(k)</math>. В результате, <math>\Psi_{distance}^d = O(log(d))</math>. Таким образом:

<math>\Psi_{distribute}^{k, d} = \Psi_{distance}^d + \Psi_{min}^k = O(log(d))+O(log(k)) = O(log(k*d))</math>

Пересчет центров кластеров в d-мерном пространстве

Поскольку на данном шаге для каждого из <math>k</math> кластеров центр масс может быть вычислен независимо, данные операции могут быть выполнены в отдельных потоках. Таким образом, параллельная сложность данного шага, <math>\Psi_{recenter}^{k, d}</math>, будет определяться параллельной сложностью вычисления одного центра масс кластера размера <math>m</math>, <math>\Psi_{recenter}^{k, d}</math>, а так как <math>m \le n \Rightarrow \Psi_{recenter}^{d, m} \le \Psi_{recenter}^{d, n}</math>. Сложность вычисления центра масс кластера d-мерных векторов размера n аналогично предыдущим вычислениям равна <math>O(log(n))</math>. Тогда:

<math>\Psi_{recenter}^{k, d} \le \Psi_{recenter}^{d, n} = O(log(n))</math>

Общая параллельная сложность алгоритма

На каждой итерации необходимо обновление центров кластеров, которые будут использованы на следующей итерации. Таким образом, итерационный процесс выполняется последовательно<ref>Zhao, Weizhong, Huifang Ma, and Qing He. "Parallel k-means clustering based on mapreduce." IEEE International Conference on Cloud Computing. Springer Berlin Heidelberg, 2009.</ref>. Тогда, поскольку сложность каждой итерации определяется <math>\Psi_{distribute}^{k, d}</math> и <math>\Psi_{recenter}</math>, сложность всего алгоритма, <math>\Psi_{k-means}</math> в предположении, что было сделано <math>\Tau</math> операций определяется выражением

<math>\Psi_{k-means} \approx \Tau * (\Psi_{distribute}^{k, d} + \Psi_{recenter}^{k, d}) \le \Tau * O(log(k*d*n))</math>

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

Входные данные 
<ul>
<li>Матрица из <math>n*d</math> элементов <math>x_{i, j} \in \mathbb{R}, i=\overline{1, n}, j=\overline{1, d}</math>– координат векторов (наблюдений).</li>
<li>Целое положительное число <math>k, k \le n</math> – количество кластеров.</li>
</ul>


Объем входных данных 
<math>1</math> целое число + <math>n*d</math> вещественных чисел (при условии, что координаты – вещественные числа).


Выходные данные 
<math>n</math> целых положительных чисел <math>L_1, ..., L_n</math>– номера кластеров, соотвествующие каждому вектору (при условии, что нумерация кластеров начинается с <math>1</math>).


Объем выходных данных 
<math>n</math> целых положительных чисел.


=== Свойства алгоритма ===
[[глоссарий#Вычислительная мощность|''Вычислительная мощность'']]
Вычислительная мощность алгоритма k means равна <math>\frac{k*d*n*\Tau}{n*d} = k*\Tau </math>, где <math>k</math> – число кластеров, <math>\Tau</math> – число итераций алгоритма.

[[глоссарий#Детерминированность |''Детерминированность'']] и [[глоссарий#Устойчивость |''Устойчивость'']] 
Алгоритм k means является итерационным. Количество итераций алгоритма в общем случае не фиксируется и зависит от начального расположения объектов в пространстве, параметра <math>k</math>, а также от начального приближения центров кластеров, <math>\mu_1, ..., \mu_k</math>. В результате этого может варьироваться результат работы алгоритма. При неудачном выборе начальных параметров итерационный процесс может сойтись к локальному оптимуму<ref>Von Luxburg, Ulrike. Clustering Stability. Now Publishers Inc, 2010.</ref>. По этим причинам алгоритм не является ни детермирированным, ни устойчивым.

Соотношение последовательной и параллельной сложности алгоритма

<math>\frac{\Theta_{k-means}}{\Psi_{k-means}} = \frac{O(\Tau*k*d*n)}{O(\Tau*log(k*d*n))}</math>

Сильные стороны алгоритма:
<ul>
<li>Сравнительно высокая эффективность при простоте реализации</li>
<li>Высокое качество кластеризации</li>
<li>Возможность распараллеливания</li>
<li>Существование множества модификаций</li>
</ul>
Недостатки алгоритма<ref>Ortega, Joaquín Pérez, Ma Del Rocío Boone Rojas, and María J. Somodevilla. "Research issues on K-means Algorithm: An Experimental Trial Using Matlab."</ref>:
<ul>
<li>Количество кластеров является параметром алгоритма</li>
<li>
Чувствительность к начальным условиям
Инициализация центров кластеров в значительной степени влияет на результат кластеризации.
</li>
<li>
Чувствительность к выбросам и шумам
Выбросы, далекие от центров настоящих кластеров, все равно учитываются при вычислении их центров.
</li>
<li>
Возможность сходимости к локальному оптимуму
Итеративный подход не дает гарантии сходимости к оптимальному решению.
</li>
<li>
Использование понятия "среднего"
Алгоритм неприменим к данным, для которых не определено понятие "среднего", например, категориальным данным.
</li>
</ul>

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

Исследование масштабируемости параллельной реализации алгоритма k means проводилось на суперкомпьютере "Ломоносов"<ref name="Lom">Воеводин Вл., Жуматий С., Соболев С., Антонов А., Брызгалов П., Никитенко Д., Стефанов К., Воеводин Вад. Практика суперкомпьютера «Ломоносов» // Открытые системы, 2012, N 7, С. 36-39.</ref> [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета]. Алгоритм реализован на языке C с использованием средств MPI.
Для исследования масштабируемости проводилось множество запусков программы с разным значением параметра (количество векторов для кластеризации), а также с различным числом процессоров. Фиксировались результаты запусков – время работы <math>t</math> и количество произведенных итераций алгоритма <math>\Tau</math>.

Параметры запусков для экспериментальной оценки:
<ul>
<li>Значения количества векторов <math>n</math>: 20'000, 30'000, 50'000, 100'000, 200'000, 300'000, 500'000, 700'000, 1'000'000, 1'500'000, 2'000'000.</li>
<li>Значения количества процессоров <math>p</math>: 1, 8, 16, 32, 64, 128, 160, 192, 224, 256, 288, 320, 352, 384, 416, 448, 480, 512.</li>
<li>Значение количества кластеров <math>k</math>: 100.</li>
<li>Значение размерности векторов <math>d</math>: 10.</li>
</ul>

Для проведения экспериментов были сгенерированы нормально распределенные псевдослучайные данные (с использованием Python библиотеки [http://scikit-learn.org/ scikit-learn]):
<syntaxhighlight lang="python">
from sklearn.datasets import make_classification
X1, Y1 = make_classification(n_features=10, n_redundant=2, n_informative=8,
n_clusters_per_class=1, n_classes=100,
n_samples=2000000)
</syntaxhighlight>

Для заданной конфигурации эксперимента (<math>n, d, p, k</math>) и полученных результатов (<math>t, \Tau</math>) [[Глоссарий#Производительность|производительность]] и эффективность реализации расчитывались по формулам:

<ul><li><math>Performance = \frac{N_{k-means}^{d, n}}{t}\ \ (FLOPS),</math></li></ul>
где <math>N_{k-means}^{d, n}</math> – точное число операций с плавающей точкой (операции с памятью, а также целочисленные операции не учитывались), вычисленное в соответствие с разделом [[#Последовательная сложность алгоритма| "Последовательная сложность алгоритма"]];


<ul><li><math>Efficiency = \frac{100 * Performance}{Performance_{Peak}^{p}}\ \ (%),</math></li></ul>
где <math>Performance_{Peak}^{p}</math> – пиковая производительность суперкомпьютера при <math>p</math> процессорах, вычисленная согласно спецификациям Intel® XEON® X5670<ref>"http://ark.intel.com/ru/products/47920/Intel-Xeon-Processor-X5670-12M-Cache-2_93-GHz-6_40-GTs-Intel-QPI"</ref>.


Графики зависимости производительности и эффективности параллельной реализации k means от числа векторов для кластеризации (<math>n</math>) и числа процессоров (<math>p</math>) представлены на рисунках 4 и 5 соответственно.

[[file:Flops.png|thumb|center|800px|Рис. 4. Параллельная реализация k means. График зависимости производительности реализации алгоритма от числа векторов для кластеризации (<math>n</math>) и числа процессоров (<math>p</math>).]]
[[file:Efficiency.png|thumb|center|800px|Рис. 5. Параллельная реализация k means. График зависимости эффективности реализации алгоритма от числа векторов для кластеризации (<math>n</math>) и числа процессоров (<math>p</math>).]]


В результате экспериментальной оценки были получены следующие оценки эффективности реализации:
<ul>
<li>Минимальное значение: 0.000409 % достигается при <math>n=20'000, p=480</math></li>
<li>Максимальное значение: 0.741119 % достигается при <math>n=300'000, p=1</math></li>
</ul>



Оценки масштабируемости реализации алгоритма k means:
<ul>
<li>По числу процессоров: -0.002683 – эффективность убывает с ростом числа процессоров. Данный результат вызван ростом накладных расходов для обеспечения параллельного выполнения алгоритма.</li>
<li>По размеру задачи: 0.002779 – эффективность растет с ростом числа векторов. Данный результат вызван тем, что при увеличении размера задачи, количество вычислений растет по сравнению с временем, затрачиваемым на пересылку данных.</li>
<li>Общая оценка: -0.000058 – можно сделать вывод, что в целом эффективность реализации незначительно уменьшается с ростом размера задачи и числа процессоров.</li>
</ul>


[https://github.com/serban/kmeans Использованная параллельная реализация алгоритма k means]

=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===
==== Открытое программное обеспечение ====
<ol>
<li>[https://www.icpsr.umich.edu/CrimeStat/ CrimeStat]</li> Программное обеспечение, созданное для операционных систем Windows, предоставляющее инструменты статистического и пространственного анализа для решения задачи картирования преступности.
<li>[http://juliastats.github.io Julia]</li> Высокоуровневый высокопроизводительный свободный язык программирования с динамической типизацией, созданный для математических вычислений, содержит реализацию k-means.
<li>[https://mahout.apache.org Mahout]</li> Apache Mahout - Java библиотека для работы с алгоритмами машинного обучения с использованием MapReduce. Содержит реализацию k-means.
<li>[https://www.gnu.org/software/octave/ Octave]</li> Написанная на C++ свободная система для математических вычислений, использующая совместимый с MATLAB язык высокого уровня, содержит реализацию k-means.
<li>[http://spark.apache.org/docs/latest/mllib-clustering.html Spark]</li> Распределенная реализация k-means содержится в библиотеке Mlib для работы с алгоритмами машинного обучения, взаимодействующая с Python библиотекой NumPy и библиотека R.
<li>[http://torch.ch Torch]</li> MATLAB-подобная библиотека для языка программирования Lua с открытым исходным кодом, предоставляет большое количество алгоритмов для глубинного обучения и научных расчётов. Ядро написано на Си, прикладная часть выполняется на LuaJIT, поддерживается распараллеливание вычислений средствами CUDA и OpenMP. Существуют реализации k-means.
<li>[http://www.cs.waikato.ac.nz/ml/weka/ Weka]</li> Cвободное программное обеспечение для анализа данных, написанное на Java. Содержит k-means и x-means.
<li>[http://accord-framework.net/docs/html/T_Accord_MachineLearning_KMeans.htm Accord.NET]</li> C# реализация алгоритмов k-means, k-means++, k-modes.
<li>[http://docs.opencv.org/3.0-beta/doc/py_tutorials/py_ml/py_kmeans/py_kmeans_opencv/py_kmeans_opencv.html OpenCV]</li> Написанная на С++ библиотека, направленная в основном на решение задач компьютерного зрения. Содержит реализацию k-means.
<li>[http://mlpack.org/ MLPACK]</li> Масштабируемая С++ библиотека для работы с алгоритмами машинного обучения, содержит реализацию k-means.
<li>[https://www.scipy.org/ SciPy]</li> Библиотека Python, содержит множество реализаций k-means.
<li>[http://scikit-learn.org/ scikit-learn]</li> Библиотека Python, содержит множество реализаций k-means.
<li>[https://www.r-bloggers.com/k-means-clustering-in-r/ R]</li> Язык программирования для статистической обработки данных и работы с графикой, а также свободная программная среда вычислений с открытым исходным кодом в рамках проекта GNU, содержит три реализации k-means.
<li>[http://elki.dbs.ifi.lmu.de ELKI]</li> Java фреймворк, содержащий реализацию k-means, а также множество других алгоритмов кластеризации.
</ol>
==== Проприетарное программное обеспечение ====

<ol>
<li>[https://www.ayasdi.com/blog/bigdata/topological-data-analysis-of-oil-and-gas-petrophysical-data/ Ayasdi]</li>
<li>[http://www.stata.com/features/cluster-analysis/ Stata]</li>
<li>[http://mathworld.wolfram.com/K-MeansClusteringAlgorithm.html Mathematica]</li>
<li>[http://www.mathworks.com/help/stats/kmeans.html?requestedDomain=www.mathworks.com MATLAB]</li>
<li>[https://support.sas.com/rnd/app/stat/procedures/fastclus.html SAS]</li>
<li>[http://docs.rapidminer.com/studio/operators/modeling/segmentation/k_means.html RapidMiner]</li>
<li>[https://blogs.sap.com/2013/03/28/sap-hana-pal-k-means-algorithm-or-how-to-do-customer-segmentation-for-the-telecommunications-industry/ SAP HANA]</li>
</ol>
== Литература ==
<references />

Участник:Илья Егоров/Алгоритм k-средних

2016-11-23T07:18:34Z

Zhum:

{{Assignment|Zhum}}

{{algorithm
| name = Алгоритм k-средних (k-means)
| serial_complexity = <math>O(n*k*d)</math>
| input_data = <math>n*d</math>
| output_data = <math>n</math>
}}

Страница создана группой "[[U:Илья Егоров|Илья Егоров]] — [[U:Богомазов Евгений|Евгений Богомазов]]".

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

= ЧАСТЬ. Свойства и структура алгоритмов =
== Общее описание алгоритма ==

Алгоритм кластеризации k-средних впервые был предложен в 1950-х годах математиками Гуго Штейнгаузом и Стюартом Ллойдом независимо друг от друга. Наибольшую популярность он получил после работы Маккуина.

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

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

== Математическое описание алгоритма ==
'''Исходные данные:'''
* Совокупность n d-мерных векторов <math> X = \{x_1 \dots x_n\} , </math> где <math> x_i = \{x_{i1} \dots x_{id}\} </math>
* Предполагаемое количество кластеров k

'''Выходные данные:'''
* Разбиение X на множество <math> S = \{S_1 \dots S_k \}, \bigcup S_i = X, S_i \cap S_j = \emptyset, i \neq j </math>
* k центров кластеров <math> \Mu = \{\mu_1 \dots \mu_k \} </math>, где <math> \mu_i = \{\mu_{i1} \dots \mu_{id} \} </math> такие, что

<math> \begin{cases}\tilde{\mu_i} = \underset{y}{argmin } \sum_{x \in S_i} ||x-y||^2_E \\ \Mu = \underset{\tilde{\Mu}}{argmin } \sum_{i \in k} \sum_{x \in S_i} ||x-\tilde{\mu_i}||^2_E \end{cases} </math>

'''Алгоритм:'''

1) <math> \mu_{i} = random </math>

2) <math> S_i = \{x \in S~|~\underset{j}{argmin } ||x-\mu_j||_E = i\} i = 1 \dots k </math>

3) <math> \tilde{\mu_{i}} = E_{x \in S_i}(x) </math>

4) Если для <math> \forall i: \mu_i = \tilde{\mu_i} </math> то алгоритм завершен, иначе <math> \mu_i = \tilde{\mu_i} </math> и перейти на пункт 2)

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

Вычислительным ядром алгоритма является второй этап, а точнее нахождение матрицы расстояний между <math>X</math> и <math>\Mu</math>. Для '''d'''-мерного вектора <math>a:</math>

<math>||a||=\sqrt{\sum_{i=1\dots d} a_i^2}</math>, поэтому заполнение одной ячейки такой матрицы потребует <math>d</math> операций умножения, <math>d-1</math> операций сложения и одну операция вычисления квадратного корня. Но так как эти расстояния используются только для сравнения, а ''sqrt'' является монотонно возрастающей функцией, то ее можно не вычислять. Поэтому нахождения матрицы расстояний потребует всего <math>n*k*d</math> операций умножений и <math>n*k*(d-1)</math> операций сложений.

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

В алгоритме можно выделить следующие макрооперации:
*'''Вычисление расстояния между векторами''',
*'''Суммирование векторов''',
*'''Поиск минимума в векторе''',
*'''Сравнение векторов''',
*'''Деление вектора на скаляр'''.

'''1)''' На шаге инициализации центроидов в общем случае (случайный выбор элементов) макроопераций не производится. Но так как правило определения количества кластеров '''k''' неоднозначно, то для некоторых вариантов макрооперации могут понадобиться. К примеру, существует класс стратегий поиска '''k''', которые базируются на определении центра масс всех объектов, и для которых будут дополнительно выполняться макрооперации '''"Суммирование векторов"''' и '''"Деление вектора на скаляр"'''.

'''2a)''' При составлении матрицы расстояний ''' k <math> \cdot </math> n''' раз производится макрооперация '''"Вычисление расстояния между векторами"'''.

'''2b)''' При нахождение вектора распределения объектов по кластерам '''n''' раз производится макрооперация '''"Поиск минимума в векторе"'''.

'''3)''' При пересчете центроидов '''n - k''' раз производится макрооперация '''"Суммирование векторов"''' и '''k''' раз — '''"Деление вектора на скаляр"'''.

'''4)''' Для проверки критерия останова требуется '''k''' раз произвести макрооперацию '''"Сравнение векторов"''' для сопоставления обновленных значений центроидов с уже имеющимися.

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

Последовательность шагов алгоритма следующая:

'''1) Инициализация центроидов <math>\Mu</math>, <math> iter = 1 </math>, задание максимального количество итераций <math>maxiter</math>'''

'''2a) Нахождение матрицы расстояний '''<math>dist:</math>

<math>dist_{ij} = \sum_{l = 1\dots d} (x_{il}-\mu_{jl})^2</math>

'''2b) Нахождение вектора распределения объектов по кластерам '''<math>index: </math>

<math>index_{i} = \underset{j}{argmin }~dist_{ij} </math>

'''3) Пересчет центроидов '''<math>\tilde{\Mu}:</math>

<math>\tilde{\mu_{ij}} = \sum_{l \in S_i} \dfrac{x_{lj}}{|S_i|} </math>, где <math>S_i = \{l~|~l \in 1\dots n, index_l = i\} </math>

'''4) Проверка критерия останова:'''

'''Если''' <math> \exists i: \tilde{\mu_i} \neq \mu_i</math>, <math> iter < maxiter </math>,

'''то''' <math> inc(iter), \Mu=\tilde{\Mu},</math> '''GOTO 2.а.'''

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

'''1)''' Сложность инициализации в общем случае зависит от применяемого метода генерации/получения случайных чисел, но ей можно пренебречь

'''2a)''' Вычисление матрицы расстояний требует <math> n*k*d </math> операций умножения и <math> n*k*(d-1) </math> операций сложения

'''2b)''' Нахождение вектора распределения требует <math> n*(k-1) </math> операций сравнения

'''3)''' Для вычисления <math> \tilde{\Mu} </math> требуется <math> (n - k + 1) * d </math> операций сложения и <math> k * d </math> операций деления

'''4)''' Для критерия останова требуется <math> n*d </math> сравнений

Итого: так как максимальное количество итераций задается в алгоритме заранее и не зависит от входных данных, то количество итераций ограничено константой. Тогда сложность алгоритма:

* <math> O(n*k*d)</math> операций сложения/вычитания
* <math> O(n*k*d)</math> операций умножения, <math> O(k*d) </math> операций деления

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

Рассмотрим вычислительные этапы алгоритма k-means. Это распределение объектов по кластерам и перерасчет центроидов.

Распределение объектов по кластерам состоит из нахождения матрицы расстояний между <math>X</math> и <math>\Mu</math> (этапа '''2a)''') и нахождения индекса минимального элемента в каждой строке (этап '''2b)'''). Ниже приведен информационный граф данного этапа.

[[Файл:EgorovBogomazovInf.png |800px|thumb|center|Нахождение вектора индексов распределения по кластерам]]

Рассмотрим этап вычисления ячейки <math> dist_{ij} </math> матрицы более подробно. Он представляет из себя скалярное произведение d-мерных векторов <math> x_i </math> и <math> \mu_j </math>. Ниже приведена граф для данной операции.

[[Файл:EgorovBogomazovDist.png|600px|thumb|center|Операция вычисления расстояния]]

На этапе '''3)''' происходит суммирование всех <math> x_l </math> с одинаковым значением индекса в промежуточные суммы. Одновременно происходит подсчет количество элементов с фиксированным индексом. Затем происходит деление промежуточных сумм на соответствующее количество элементов в новом кластере, благодаря чему удается получить обновленные центроиды <math> \tilde{\mu}</math>

[[Файл:EgorovBogomazovNewCluster.png|800px|thumb|center|Обновление центроидов]]

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

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

'''2a)''' Нахождение каждой ячейки матрицы <math> dist </math> может происходить полностью независимо, так как они находятся на одном ярусе. При рассмотрении операции вычисления значения конкретной ячейки <math> dist_{ij} </math> можно заметить, что все операции умножения также независимы между собой, поэтому понадобится всего одно умножение. Конечный результат получается в результате суммирования всех слагаемых и достигается параллельно за <math> \log(d) </math> бинарных операций сложения при помощи стандартного метода ''reduction''.

'''2b)''' Нахождение вектора распределений заключается в нахождении минимального элемента в каждой строке матрицы <math> dist </math>. При использовании ''reduction'' эту операцию можно выполнить за <math> \log(k) </math> бинарных операций сравнения.

'''3)''' В случае, если существует методология быстрого разделения '''n''' объектов на '''k''' множеств при помощи вектора индексации (косвенной адресации), все <math> \tilde{S_i} </math> могут быть обработаны параллельно. В рамках каждого отдельного <math> \tilde{S_i} </math> можно проводить распараллеливание дальше, так как <math> x_{lj} </math> также не зависят друг от друга. Таким образом, вычисление всех слагаемых для всех <math> \tilde{\mu_{ij}} </math> может быть выполнено за одно параллельное деление, а нахождение суммы всех этих слагаемых для каждого <math> \tilde{\mu_{ij}} </math> может быть выполнено за <math> O(log(n)) </math> в худшем случае (при вхождении почти всех объектов в один кластер).

Если же такой методологии не существует, то узким местом становится процесс распределения на множества согласно вектору <math>index</math>, который можно выполнить за <math> n </math> операций косвенных адресаций.

'''4)''' Все сравнения для критерия останова также независимы между собой и могут быть выполнены за одну операцию сравнения, а финальный результат может быть получен за одну операцию сложения при работе над общей памятью (к примеру, прибавление единицы при несовпадении в общую память и сравнение ее с 0 по завершению) или за <math>\log(k*d)</math> сложений иначе.

Так как количество итераций ограничено константой, то на сложность оно не влияет. В итоге, параллельная сложность алгоритма k-means такова:
* <math> O(\log(n*d)) </math> операций сложения
* <math> O(\log(k)) </math> операций сравнения
* <math> O(1) </math> операций умножения и деления

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

'''Входные данные''': Количество кластеров k, n кластеризуемых элементов

Дополнительные ограничения:
* k — положительное число, т. е. k > 0.
* Для кластеризуемых элементов определена метрика (расстояние между объектами)

'''Объём входных данных''': n <math>\cdot</math> d + 1 (кластеризуемые объекты в виде векторов и число k)

'''Выходные данные''': Массив, в который записаны принадлежности каждого элемента кластеру (допустим вывод в другой эквивалентной более удобной структуре).

'''Объём выходных данных''': Размер массива равен 2 <math>\cdot</math> n.

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

'''Вычислительная мощность'''

Число действий: <math>n\cdot k\cdot d</math> умножений

Объем входных данных: <math>n \cdot d + 1</math>

Вычислительная мощность <math> = \dfrac{n \cdot k \cdot d}{n\cdot d + 1} = k</math> операций на единицу переданных данных за одну итерацию.

'''Ограничения алгоритма'''

Алгоритм эффективно работает только на небольших объемах данных.

'''Преимущества алгоритма'''
* Простота использования
* Быстрота использования
* Понятность и прозрачность описания
* Обладает вычислительной устойчивостью
* Предрасположенность к распараллеливанию
* Достаточно популярный, поэтому имеет множество реализаций и вариаций

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

* Нет проверки корректности выбора числа кластеров
* Алгоритм чувствителен к количеству кластеров
* Алгоритм чувствителен к выбору начальных элементов в качестве центроидов
* Алгоритм крайне чувствителен к выбросам по данным
* Медленная работа на больших объемах данных

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

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

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

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

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

Проведём исследование масштабируемости параллельной реализации алгоритма k-средних. Исследование проводилось на суперкомпьютере "Ломоносов" [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета]. Параллельная реализация была написана самостоятельно на языке C, [http://git.algowiki-project.org/iaegorov/Egorov-Bogomazov-k-means/tree/master ссылка на реализацию]. Так как на каждой итерации число действий на единицу данных не велико и данные должны быть собраны вместе при перерасчете центроидов, было решено для ускорения вычислений '''воспользоваться только OpenMP без MPI'''.

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

* число процессоров [1 : 16] с увеличением в 2 раза;
* размер данных [100000 : 1600000] с увеличением в 2 раза.

В результате проведённых экспериментов были получены следующие данные:

* Максимальная эффективность в точке достигается при переходе от 1 потока на 8 при минимальном размере данных, она равна <math>87,5%</math>.
* Усредненная максимальная эффективность достигается при переходе с одного потока на два. Среднее время вычислений на всех рассмотренных потока снижается с 16,33 до 11.87 секунд, поэтому формально эффективность <math>= 16.33 / 11.87 / 2 \approx 68,4\%</math>
* Минимальная эффективность в точке достигается при переходе от 1 потока на 16 при размере данных 800000, она равна <math>11,1\%</math>.
* Усредненная минимальная эффективность наблюдается при переходе с одного на максимальное рассматриваемое в эксперименте число потоков, равное 16. Время вычисления изменяется с 16,33 до 7,6 секунд, поэтому формально эффективность <math> = 16.33 / 7.6 / 16 \approx 14,9\%</math>

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

[[file:Egorov_Bogomazov_Time.jpg|thumb|center|700px|Параллельная реализация алгоритма k-средних. Изменение вычислительного времени алгоритма в зависимости от числа процессоров и размера исходных данных.]]

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

[[file:Egorov_Bogomazov_Efficiency.jpg|thumb|center|700px|Параллельная реализация алгоритма k-средних. Изменение эффективности алгоритма в зависимости от числа процессоров и размера исходных данных.]]

Здесь построена эффективность перехода от последовательной реализации к параллельной. Рассчитывается она по формуле ''Время вычисления на 1 потоке / Время вычисления на T потоках / T'', где T — это число потоков. При вычислении на 1 процессоре она равна 100 % в силу используемой формулы, что и отражено на графике.

Проведем оценки масштабируемости:

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

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

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

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

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

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

=== Бесплатный доступ ===

'''Десктопные программы'''

* [http://www.cs.waikato.ac.nz/ml/weka/ Weka]
* [http://docs.orange.biolab.si/2/reference/rst/Orange.clustering.kmeans.html Orange]

'''Фреймворки для языков'''

* '''Python:'''
** [http://scikit-learn.org/ scikit-learn]
** [https://www.scipy.org/ SciPy]
* '''C++:'''
** [http://mlpack.org/ MLPACK]
** [http://docs.opencv.org/3.0-beta/doc/py_tutorials/py_ml/py_kmeans/py_kmeans_opencv/py_kmeans_opencv.html OpenCV]
** [https://www.gnu.org/software/octave/ Octave]
* '''C#:'''
** [http://accord-framework.net/docs/html/T_Accord_MachineLearning_KMeans.htm Accord.NET]
* '''Java:'''
** [http://elki.dbs.ifi.lmu.de ELKI]
** [https://mahout.apache.org Mahout]
* '''Lua'''
** [http://torch.ch Torch]

Языки [https://www.r-bloggers.com/k-means-clustering-in-r/ R] и [http://juliastats.github.io Julia] содержат алгоритм k-means в базовой реализации.

=== Платный доступ/лицензия ===

Существует целый перечень мощных статистических и математических пакетов для разных ОС:
* [http://www.mathworks.com/help/stats/kmeans.html?requestedDomain=www.mathworks.com MATLAB]
* [http://mathworld.wolfram.com/K-MeansClusteringAlgorithm.html Mathematica]
* [http://www.stata.com/features/cluster-analysis/ Stata]
* [https://support.sas.com/rnd/app/stat/procedures/fastclus.html SAS]
* [https://blogs.sap.com/2013/03/28/sap-hana-pal-k-means-algorithm-or-how-to-do-customer-segmentation-for-the-telecommunications-industry/ SAP HANA]
* [http://docs.rapidminer.com/studio/operators/modeling/segmentation/k_means.html RapidMiner]
* ...

= Литература =
[1] Нейский И.М. Классификация и сравнение методов кластеризации http://it-claim.ru/Persons/Neyskiy/Article2_Neiskiy.pdf

[2] https://ru.wikipedia.org/wiki/K-means

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

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

2016-11-16T08:28:45Z

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_h} )</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

2016-11-16T08:28:35Z

Zhum:

п. 2.4

* не указано, какая реализация алгоритма использовалась - собственная или библиотечная
[[Участник:Zhum|Zhum]] ([[Обсуждение участника:Zhum|обсуждение]]) 11:28, 16 ноября 2016 (MSK)

Обсуждение участника:Илья Егоров

2016-11-16T08:17:37Z

Zhum:

п. 2.4

* нет текста программы
* нет указания на реализацию алгоритма (своя или сторонняя)
* нет пояснений к графикам
* либо заполните п. 2.4.1, либо уберите подпункты.
[[Участник:Zhum|Zhum]] ([[Обсуждение участника:Zhum|обсуждение]]) 11:17, 16 ноября 2016 (MSK)

Обсуждение участника:Илья Егоров

2016-11-16T08:16:14Z

Zhum:

п. 2.4

* нет текста программы
* нет указания на реализацию алгоритма (своя или сторонняя)
* нет пояснений к графикам
[[Участник:Zhum|Zhum]] ([[Обсуждение участника:Zhum|обсуждение]]) 11:16, 16 ноября 2016 (MSK)

Участник:Илья Егоров/Алгоритм k-средних

2016-11-16T08:16:07Z

Zhum:

{{algorithm
| name = Алгоритм k-средних (k-means)
| serial_complexity = <math>O(n*k*d)</math>
| input_data = <math>n*d</math>
| output_data = <math>n</math>
}}

Страница создана группой "[[U:Илья Егоров|Илья Егоров]] — [[U:Богомазов Евгений|Евгений Богомазов]]".

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

= ЧАСТЬ. Свойства и структура алгоритмов =
== Общее описание алгоритма ==

Алгоритм кластеризации k-средних впервые был предложен в 1950-х годах математиками Гуго Штейнгаузом и Стюартом Ллойдом независимо друг от друга. Наибольшую популярность он получил после работы Маккуина.

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

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

== Математическое описание алгоритма ==
'''Исходные данные:'''
* Совокупность n d-мерных векторов <math> X = \{x_1 \dots x_n\} , </math> где <math> x_i = \{x_{i1} \dots x_{id}\} </math>
* Предполагаемое количество кластеров k

'''Выходные данные:'''
* Разбиение X на множество <math> S = \{S_1 \dots S_k \}, \bigcup S_i = X, S_i \cap S_j = \emptyset, i \neq j </math>
* k центров кластеров <math> \Mu = \{\mu_1 \dots \mu_k \} </math>, где <math> \mu_i = \{\mu_{i1} \dots \mu_{id} \} </math> такие, что

<math> \begin{cases}\tilde{\mu_i} = \underset{y}{argmin } \sum_{x \in S_i} ||x-y||^2_E \\ \Mu = \underset{\tilde{\Mu}}{argmin } \sum_{i \in k} \sum_{x \in S_i} ||x-\tilde{\mu_i}||^2_E \end{cases} </math>

'''Алгоритм:'''

1) <math> \mu_{i} = random </math>

2) <math> S_i = \{x \in S~|~\underset{j}{argmin } ||x-\mu_j||_E = i\} i = 1 \dots k </math>

3) <math> \tilde{\mu_{i}} = E_{x \in S_i}(x) </math>

4) Если для <math> \forall i: \mu_i = \tilde{\mu_i} </math> то алгоритм завершен, иначе <math> \mu_i = \tilde{\mu_i} </math> и перейти на пункт 2)

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

Вычислительным ядром алгоритма является второй этап, а точнее нахождение матрицы расстояний между <math>X</math> и <math>\Mu</math>. Для '''d'''-мерного вектора <math>a:</math>

<math>||a||=\sqrt{\sum_{i=1\dots d} a_i^2}</math>, поэтому заполнение одной ячейки такой матрицы потребует <math>d</math> операций умножения, <math>d-1</math> операций сложения и одну операция вычисления квадратного корня. Но так как эти расстояния используются только для сравнения, а ''sqrt'' является монотонно возрастающей функцией, то ее можно не вычислять. Поэтому нахождения матрицы расстояний потребует всего <math>n*k*d</math> операций умножений и <math>n*k*(d-1)</math> операций сложений.

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

В алгоритме можно выделить следующие макрооперации:
*'''Вычисление расстояния между векторами''',
*'''Суммирование векторов''',
*'''Поиск минимума в векторе''',
*'''Сравнение векторов''',
*'''Деление вектора на скаляр'''.

'''1)''' На шаге инициализации центроидов в общем случае (случайный выбор элементов) макроопераций не производится. Но так как правило определения количества кластеров '''k''' неоднозначно, то для некоторых вариантов макрооперации могут понадобиться. К примеру, существует класс стратегий поиска '''k''', которые базируются на определении центра масс всех объектов, и для которых будут дополнительно выполняться макрооперации '''"Суммирование векторов"''' и '''"Деление вектора на скаляр"'''.

'''2a)''' При составлении матрицы расстояний ''' k <math> \cdot </math> n''' раз производится макрооперация '''"Вычисление расстояния между векторами"'''.

'''2b)''' При нахождение вектора распределения объектов по кластерам '''n''' раз производится макрооперация '''"Поиск минимума в векторе"'''.

'''3)''' При пересчете центроидов '''n - k''' раз производится макрооперация '''"Суммирование векторов"''' и '''k''' раз - '''"Деление вектора на скаляр"'''.

'''4)''' Для проверки критерия останова требуется '''k''' раз произвести макрооперацию '''"Сравнение векторов"''' для сопоставления обновленных значений центроидов с уже имеющимися.

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

Последовательность шагов алгоритма следующая:

'''1) Инициализация центроидов <math>\Mu</math>, <math> iter = 1 </math>, задание максимального количество итераций <math>maxiter</math>'''

'''2a) Нахождение матрицы расстояний '''<math>dist:</math>

<math>dist_{ij} = \sum_{l = 1\dots d} (x_{il}-\mu_{jl})^2</math>

'''2b) Нахождение вектора распределения объектов по кластерам '''<math>index: </math>

<math>index_{i} = \underset{j}{argmin }~dist_{ij} </math>

'''3) Пересчет центроидов '''<math>\tilde{\Mu}:</math>

<math>\tilde{\mu_{ij}} = \sum_{l \in S_i} \dfrac{x_{lj}}{|S_i|} </math>, где <math>S_i = \{l~|~l \in 1\dots n, index_l = i\} </math>

'''4) Проверка критерия останова:'''

'''Если''' <math> \exists i: \tilde{\mu_i} \neq \mu_i</math>, <math> iter < maxiter </math>,

'''то''' <math> inc(iter), \Mu=\tilde{\Mu},</math> '''GOTO 2.а.'''

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

'''1)''' Сложность инициализации в общем случае зависит от применяемого метода генерации/получения случайных чисел, но ей можно пренебречь

'''2a)''' Вычисление матрицы расстояний требует <math> n*k*d </math> операций умножения и <math> n*k*(d-1) </math> операций сложения

'''2b)''' Нахождение вектора распределения требует <math> n*(k-1) </math> операций сравнения

'''3)''' Для вычисления <math> \tilde{\Mu} </math> требуется <math> (n - k + 1) * d </math> операций сложения и <math> k * d </math> операций деления

'''4)''' Для критерия останова требуется <math> n*d </math> сравнений

Итого: так как максимальное количество итераций задается в алгоритме заранее и не зависит от входных данных, то количество итераций ограничено константой. Тогда сложность алгоритма:

* <math> O(n*k*d)</math> операций сложения/вычитания
* <math> O(n*k*d)</math> операций умножения, <math> O(k*d) </math> операций деления

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

Рассмотрим вычислительные этапы алгоритма k-means. Это распределение объектов по кластерам и перерасчет центроидов.

Распределение объектов по кластерам состоит из нахождения матрицы расстояний между <math>X</math> и <math>\Mu</math> (этапа '''2a)''') и нахождения индекса минимального элемента в каждой строке (этап '''2b)'''). Ниже приведен информационный граф данного этапа.

[[Файл:EgorovBogomazovInf.png |800px|thumb|center|Нахождение вектора индексов распределения по кластерам]]

Рассмотрим этап вычисления ячейки <math> dist_{ij} </math> матрицы более подробно. Он представляет из себя скалярное произведение d-мерных векторов <math> x_i </math> и <math> \mu_j </math>. Ниже приведена граф для данной операции.

[[Файл:EgorovBogomazovDist.png|600px|thumb|center|Операция вычисления расстояния]]

На этапе '''3)''' происходит суммирование всех <math> x_l </math> с одинаковым значением индекса в промежуточные суммы. Одновременно происходит подсчет количество элементов с фиксированным индексом. Затем происходит деление промежуточных сумм на соответствующее количество элементов в новом кластере, благодаря чему удается получить обновленные центроиды <math> \tilde{\mu}</math>

[[Файл:EgorovBogomazovNewCluster.png|800px|thumb|center|Обновление центроидов]]

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

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

'''2a)''' Нахождение каждой ячейки матрицы <math> dist </math> может происходить полностью независимо, так как они находятся на одном ярусе. При рассмотрении операции вычисления значения конкретной ячейки <math> dist_{ij} </math> можно заметить, что все операции умножения также независимы между собой, поэтому понадобится всего одно умножение. Конечный результат получается в результате суммирования всех слагаемых и достигается параллельно за <math> \log(d) </math> бинарных операций сложения при помощи стандартного метода ''reduction''.

'''2b)''' Нахождение вектора распределений заключается в нахождении минимального элемента в каждой строке матрицы <math> dist </math>. При использовании ''reduction'' эту операцию можно выполнить за <math> \log(k) </math> бинарных операций сравнения.

'''3)''' В случае, если существует методология быстрого разделения '''n''' объектов на '''k''' множеств при помощи вектора индексации (косвенной адресации), все <math> \tilde{S_i} </math> могут быть обработаны параллельно. В рамках каждого отдельного <math> \tilde{S_i} </math> можно проводить распараллеливание дальше, так как <math> x_{lj} </math> также не зависят друг от друга. Таким образом, вычисление всех слагаемых для всех <math> \tilde{\mu_{ij}} </math> может быть выполнено за одно параллельное деление, а нахождение суммы всех этих слагаемых для каждого <math> \tilde{\mu_{ij}} </math> может быть выполнено за <math> O(log(n)) </math> в худшем случае (при вхождении почти всех объектов в один кластер).

Если же такой методологии не существует, то узким местом становится процесс распределения на множества согласно вектору <math>index</math>, который можно выполнить за <math> n </math> операций косвенных адресаций.

'''4)''' Все сравнения для критерия останова также независимы между собой и могут быть выполнены за одну операцию сравнения, а финальный результат может быть получен за одну операцию сложения при работе над общей памятью (к примеру, прибавление единицы при несовпадении в общую память и сравнение ее с 0 по завершению) или за <math>\log(k*d)</math> сложений иначе.

Так как количество итераций ограничено константой, то на сложность оно не влияет. В итоге, параллельная сложность алгоритма k-means такова:
* <math> O(\log(n*d)) </math> операций сложения
* <math> O(\log(k)) </math> операций сравнения
* <math> O(1) </math> операций умножения и деления

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

'''Входные данные''': Количество кластеров k, n кластеризуемых элементов

Дополнительные ограничения:
* k — положительное число, т. е. k > 0.
* Для кластеризуемых элементов определена метрика (расстояние между объектами)

'''Объём входных данных''': n <math>\cdot</math> d + 1 (кластеризуемые объекты в виде векторов и число k)

'''Выходные данные''': Массив, в который записаны принадлежности каждого элемента кластеру (допустим вывод в другой эквивалентной более удобной структуре).

'''Объём выходных данных''': Размер массива равен 2 <math>\cdot</math> n.

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

'''Вычислительная мощность'''

Число действий: <math>n\cdot k\cdot d</math> умножений

Объем входных данных: <math>n \cdot d + 1</math>

Вычислительная мощность <math> = \dfrac{n \cdot k \cdot d}{n\cdot d + 1} = k</math> операций на единицу переданных данных за одну итерацию.

'''Ограничения алгоритма'''

Алгоритм эффективно работает только на небольших объемах данных.

'''Преимущества алгоритма'''
* Простота использования
* Быстрота использования
* Понятность и прозрачность описания
* Обладает вычислительной устойчивостью
* Предрасположенность к распараллеливанию
* Достаточно популярный, поэтому имеет множество реализаций и вариаций

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

* Нет проверки корректности выбора числа кластеров
* Алгоритм чувствителен к количеству кластеров
* Алгоритм чувствителен к выбору начальных элементов в качестве центроидов
* Алгоритм крайне чувствителен к выбросам по данным
* Медленная работа на больших объемах данных

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

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

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

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

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

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

Проведём исследование масштабируемости параллельной реализации алгоритма k-средних. Исследование проводилось на суперкомпьютере "Ломоносов" [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета].

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

* число процессоров [1 : 16] с увеличением в 2 раза;
* размер данных [100000 : 1600000] с увеличением в 2 раза.

В результате проведённых экспериментов были получены следующие данные:

* Максимальная эффективность в точке достигается при переходе от 1 потока на 8 при минимальном размере данных, она равна <math>87,5%</math>.
* Усредненная максимальная эффективность достигается при переходе с одного потока на два. Среднее время вычислений на всех рассмотренных потока снижается с 16,33 до 11.87 секунд, поэтому формально эффективность <math>= 16.33 / 11.87 / 2 \approx 68,4\%</math>
* Минимальная эффективность в точке достигается при переходе от 1 потока на 16 при размере данных 800000, она равна <math>11,1\%</math>.
* Усредненная минимальная эффективность наблюдается при переходе с одного на максимальное рассматриваемое в эксперименте число потоков, равное 16. Время вычисления изменяется с 16,33 до 7,6 секунд, поэтому формально эффективность <math> = 16.33 / 7.6 / 16 \approx 14,9\%</math>

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

[[file:Egorov_Bogomazov_Time.jpg|thumb|center|700px|Параллельная реализация алгоритма k-средних. Изменение вычислительного времени алгоритма в зависимости от числа процессоров и размера исходных данных.]]

[[file:Egorov_Bogomazov_Efficiency.jpg|thumb|center|700px|Параллельная реализация алгоритма k-средних. Изменение эффективности алгоритма в зависимости от числа процессоров и размера исходных данных.]]

Оценка масштабируемости:

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

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

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

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

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

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

=== Бесплатный доступ ===

'''Десктопные программы'''

* [http://www.cs.waikato.ac.nz/ml/weka/ Weka]
* [http://docs.orange.biolab.si/2/reference/rst/Orange.clustering.kmeans.html Orange]

'''Фреймворки для языков'''

* '''Python:'''
** [http://scikit-learn.org/ scikit-learn]
** [https://www.scipy.org/ SciPy]
* '''C++:'''
** [http://mlpack.org/ MLPACK]
** [http://docs.opencv.org/3.0-beta/doc/py_tutorials/py_ml/py_kmeans/py_kmeans_opencv/py_kmeans_opencv.html OpenCV]
** [https://www.gnu.org/software/octave/ Octave]
* '''C#:'''
** [http://accord-framework.net/docs/html/T_Accord_MachineLearning_KMeans.htm Accord.NET]
* '''Java:'''
** [http://elki.dbs.ifi.lmu.de ELKI]
** [https://mahout.apache.org Mahout]
* '''Lua'''
** [http://torch.ch Torch]

Языки [https://www.r-bloggers.com/k-means-clustering-in-r/ R] и [http://juliastats.github.io Julia] содержат алгоритм k-means в базовой реализации.

=== Платный доступ/лицензия ===

Существует целый перечень мощных статистических и математических пакетов для разных ОС:
* [http://www.mathworks.com/help/stats/kmeans.html?requestedDomain=www.mathworks.com MATLAB]
* [http://mathworld.wolfram.com/K-MeansClusteringAlgorithm.html Mathematica]
* [http://www.stata.com/features/cluster-analysis/ Stata]
* [https://support.sas.com/rnd/app/stat/procedures/fastclus.html SAS]
* [https://blogs.sap.com/2013/03/28/sap-hana-pal-k-means-algorithm-or-how-to-do-customer-segmentation-for-the-telecommunications-industry/ SAP HANA]
* [http://docs.rapidminer.com/studio/operators/modeling/segmentation/k_means.html RapidMiner]
* ...

= Литература =
[1] Нейский И.М. Классификация и сравнение методов кластеризации http://it-claim.ru/Persons/Neyskiy/Article2_Neiskiy.pdf

[2] https://ru.wikipedia.org/wiki/K-means

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

Участник:Бротиковская Данута/Алгоритм k-means

2016-11-16T08:11:56Z

Zhum:

{{algorithm
| name = Алгоритм k средних (k means)
| serial_complexity = <math>O(\Tau*k*d*n)</math>
| input_data = <math> d*n </math>
| output_data = <math> n </math>
}}

Авторы страницы [[Участник:Бротиковская Данута|Данута Бротиковская]] и [[Участник:DennZo1993|Денис Зобнин]].

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

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

=== Общее описание алгоритма ===
Алгоритм k средних (k means) – неиерархический<ref>"https://ru.wikipedia.org/wiki/Иерархическая_кластеризация"</ref>, итерационный метод кластеризации<ref>"https://ru.wikipedia.org/wiki/Кластерный_анализ"</ref>, получивший большую популярность благодаря своей простоте, наглядности реализации и достаточно высокому качеству работы. Был изобретен в 1950-х годах математиком Гуго Штейнгаузом<ref>Steinhaus, Hugo. "Sur la division des corp materiels en parties." Bull. Acad. Polon. Sci 1.804 (1956): 801.</ref> и почти одновременно Стюартом Ллойдом<ref>Lloyd, S. P. "Least square quantization in PCM. Bell Telephone Laboratories Paper. Published in journal much later: Lloyd, SP: Least squares quantization in PCM." IEEE Trans. Inform. Theor.(1957/1982).</ref>. Особую популярность приобрел после публикации работы МакКуина<ref>MacQueen, James. "Some methods for classification and analysis of multivariate observations." Proceedings of the fifth Berkeley symposium on mathematical statistics and probability. Vol. 1. No. 14. 1967.</ref> в 1967.

Алгоритм представляет собой версию EM-алгоритма<ref>"https://ru.wikipedia.org/wiki/EM-алгоритм"</ref>, применяемого также для разделения смеси гауссиан. Основная идея k means заключается в том, что данные произвольно разбиваются на кластеры, после чего итеративно перевычисляется центр масс для каждого кластера, полученного на предыдущем шаге, затем векторы разбиваются на кластеры вновь в соответствии с тем, какой из новых центров оказался ближе по выбранной метрике.

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

=== Математическое описание алгоритма ===
Дано:
* набор из <math>n</math> наблюдений <math>X=\{\mathbf{x}_1, \mathbf{x}_2, ..., \mathbf{x}_n\}, \mathbf{x}_i \in \mathbb{R}^d, i=\overline{1, n}</math>;
* <math>k</math> - требуемое число кластеров, <math>k \in \mathbb{N}, k \leq n</math>.

Требуется:

Разделить множество наблюдений <math>X</math> на <math>k</math> кластеров <math>S_1, S_2, ..., S_k</math>:
* <math>S_i \cap S_j= \varnothing, \quad i \ne j</math>

* <math>\bigcup_{i=1}^{k} S_i = X</math>

Действие алгоритма:
Алгоритм k means разбивает набор <math>X</math> на <math>k</math> наборов <math>S_1, S_2, ..., S_k,</math> таким образом, чтобы минимизировать сумму квадратов расстояний от каждой точки кластера до его центра (центр масс кластера). Введем обозначение, <math>S=\{S_1, S_2, ..., S_k\}</math>. Тогда действие алгоритма k means равносильно поиску:
<table style="width:100%">
<tr>
<td align="center" width="90%"><math>\arg\min_{S} \sum\limits_{i=1}^k \sum\limits_{\mathbf{x} \in S_i} \rho(\mathbf{x}, \mathbf{\mu}_i )^2,</math></td>
<td align="right"><math>(1)</math></td>
</tr>
</table>
где <math>\mathbf{\mu}_i</math> – центры кластеров, <math>i=\overline{1,k}, \quad \rho(\mathbf{x}, \mathbf{\mu}_i)</math> – функция расстояния между <math>\mathbf{x}</math> и <math>\mu_i</math>

Шаги алгоритма: 
<ol>
<li>
Начальный шаг: инициализация кластеров
Выбирается произвольное множество точек <math>\mu_i, i=\overline{1,k}</math>, рассматриваемых как начальные центры кластеров: <math>\mu_i^{(0)} = \mu_i, \quad i=\overline{1, k}</math>
</li>
<li>
Распределение векторов по кластерам
Шаг <math>t: \forall \mathbf{x}_i \in X, i=\overline{1,n}: \mathbf{x}_i \in S_j \iff j=\arg\min_{k}\rho(\mathbf{x}_i,\mathbf{\mu}_k^{(t-1)})^2</math>
</li>
<li>
Пересчет центров кластеров
Шаг <math>t: \forall i=\overline{1,k}: \mu_i^{(t)} = \cfrac{1}{|S_i|}\sum_{\mathbf{x}\in S_i}\mathbf{x}</math>
</li>
<li>
Проверка условия останова:

'''if''' <math>\exist i\in \overline{1,k}: \mu_i^{(t)} \ne \mu_i^{(t-1)}</math> '''then'''
t = t + 1;
goto 2;
'''else'''
'''stop'''
</li>
</ol>

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

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


Распределение векторов по кластерам предполагает вычисление расстояний между каждым вектором <math>\mathbf{x}_i \in X, i= \overline{1,n}</math> и центрами кластера <math>\mathbf{\mu}_j, j= \overline{1,k}</math>. Таким образом, данный шаг предполагает <math>k*n</math> вычислений расстояний между d-мерными векторами.


Пересчет центров кластеров предполагает <math>k</math> вычислений центров масс <math>\mathbf{\mu}_i</math> множеств <math>S_i, i=\overline{1,k}</math> представленных выражением в шаге 3 представленного выше алгоритма.


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

Инициализация центров масс <math>\mu_1, ..., \mu_k</math>.

Наиболее распространенными являются следующие стратегии:
<ul>
<li>
Метод Forgy В качестве начальных значений <math>\mu_1, ..., \mu_k</math> берутся случайно выбранные векторы.
</li>
<li>
Метод случайно разделения (Random Partitioning) Для каждого вектора <math>\mathbf{x}_i \in X, i=\overline{1, n}</math> выбирается случайным образом кластер <math>S_1, ..., S_k</math>, после чего для каждого полученного кластера вычисляются значения <math>\mu_1, ..., \mu_k</math>.
</li>
</ul>

Распределение векторов по кластерам

Для этого шага алгоритма между векторами <math>\mathbf{x}_i \in X, i=\overline{1, n}</math> и центрами кластеров <math>\mu_1, ..., \mu_k</math> вычисляются расстояния по формуле (как правило, используется Евлидово расстояние):
<table style="width:100%">
<tr>
<td align="center" width="90%"><math> \mathbf{v}_1, \mathbf{v}_2 \in \mathbb{R}^d, \quad \rho(\mathbf{v}_1, \mathbf{v}_2) = \lVert \mathbf{v}_1- \mathbf{v}_2 \rVert= \sqrt{\sum_{i=1}^{d}(\mathbf{v}_{1,i} - \mathbf{v}_{2,i})^2}</math></td>
<td align="right"><math>(2)</math></td>
</tr>
</table>

Пересчет центров кластеров

Для этого шага алгоритма производится пересчет центров кластера по формуле вычисления центра масс:
<table style="width:100%">
<tr>
<td align="center" width="90%"><math> \mu = \cfrac{1}{|S|}\sum_{\mathbf{x}\in S}\mathbf{x}</math></td>
<td align="right"><math>(3)</math></td>
</tr>
</table>

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

'''algorithm''' k-means '''is'''
'''1.''' Инициализировать центры кластеров <math>\mathbf{\mu}_i^{(1)}, i=\overline{1,k}</math>
'''2.''' <math>t \leftarrow 1</math>
'''3.''' '''Распределение по кластерам''' 
<math>S_i^{(t)}=\{\mathbf{x}_p: \lVert\mathbf{x}_p-\mathbf{\mu}_i^{(t)}\rVert^2 \leq \lVert\mathbf{x}_p-\mathbf{\mu}_j^{(t)}\rVert^2 \quad \forall j=\overline{1,k}\},</math> 
где каждый вектор <math>\mathbf{x}_p</math> соотносится единственному кластеру <math>S^{(t)}</math>
'''4.''' '''Обновление центров кластеров''' 
<math>\mathbf{\mu}_i^{(t+1)} = \frac{1}{|S^{(t)}_i|} \sum_{\mathbf{x}_j \in S^{(t)}_i} \mathbf{x}_j </math> 
'''5.''' '''if''' <math>\exist i \in \overline{1,k}: \mathbf{\mu}_i^{(t+1)} \ne \mathbf{\mu}_i^{(t)}</math> '''then'''
t = t + 1;
goto '''3''';
'''else'''
'''stop'''

=== Последовательная сложность алгоритма===
<div style="padding-bottom: 20px">
Обозначим <math>\Theta_{centroid}^{d, m}</math> временную сложность вычисления центорида кластера, число элементов которого равна <math>m</math>, в d-мерном пространстве.
Аналогично <math>\Theta_{distance}^d</math> – временная сложность вычисления расстояния между двумя d-мерными векторами.
</div>
<div style="padding-bottom: 20px">
Сложность шага инициализации <math>k</math> кластеров мощности <math>m</math> в d-мерном пространстве – <math>\Theta_{init}^{k, d, m}</math>
<ul>
<li>Стратерия Forgy: вычисления не требуются, <math>\Theta_{init}^{k, d, m} = 0</math></li>
<li>Стратегия случайного разбиения: вычисление центров <math>k</math> кластеров, <math>\Theta_{init}^{k, d, m} = k*\Theta_{centroid}^{d, m}, m \le n</math></li>
</ul>
</div>
<div style="padding-bottom: 20px">
Cложность шага распределения d мерных векторов по <math>k</math> кластерам – <math>\Theta_{distribute}^{k, d}</math>

На этом шаге для каждого вектора <math>\mathbf{x}_i \in X, i=\overline{1, n}</math> вычисляется k расстояний до центров кластеров <math>\mathbf{\mu}_1, ...\mathbf{\mu}_k</math>


<math>\Theta_{distribute}^{k, d} = n*k*\Theta_{distance}^d</math>

</div>
<div style="padding-bottom: 20px">

Сложность шага пересчета центров <math>k</math> кластеров размера <math>m</math> в d-мерном пространстве – <math>\Theta_{recenter}^{k, d, m}</math>

На этом шаге вычисляется <math>k</math> центров кластеров <math>\mathbf{\mu}_1, ...\mathbf{\mu}_k</math>
<math>\Theta_{recenter}^{k, d, m} = k*\Theta_{centroid}^{d, m}</math> 
</div>
<div style="padding-bottom: 20px">
Рассчитаем <math>\Theta_{centroid}^{d, m}</math> для кластера, число элементов которого равно <math>m</math>
<math>\Theta_{centroid}^{d, m}</math> = <math>m * d</math> сложений + <math>d</math> делений 
</div>
<div style="padding-bottom: 20px">
Рассчитаем <math>\Theta_{distance}^d</math> в соответствие с формулой <math>(2)</math>
<math>\Theta_{distance}^d</math> = <math>d</math> вычитаний + <math>d</math> умножений + <math>(d-1)</math> сложение
</div>
<div style="padding-bottom: 20px">
Предположим, что алгоритм сошелся за <math>\Tau</math> итераций, тогда временная сложность алгоритма <math>\Theta_{k-means}^{d, n}</math>
<math>\Theta_{k-means}^{d, n} \le \Theta_{init}^{k, d, n} + \Tau*(\Theta_{distribute}^{k, d} + \Theta_{recenter}^{k, d, n})</math>
</div>
<div style="padding-bottom: 5px">
Операции сложения/вычитания:
<math>\Theta_{k-means}^{d, n} \le k*n*d+ \Tau*(k*n*(2d-1) + k*n*d) = k*n*d+ \Tau*(k*n*(3d-1)) \thicksim O(\Tau*k*d*n)</math>
</div>
<div style="padding-bottom: 20px">
Операции умножения/деления:
<math>\Theta_{k-means}^{d, n} \le k*d + \Tau*(k*n*d + k*d) = k*d + \Tau * k*d*(n+1) \thicksim O(\Tau*k*d*n) </math>
</div>
<div style="padding-bottom: 20px">
Получаем, что временная сложность алгоритма k means кластеризации <math>n</math> d-мерных векторов на <math>k</math> кластеров за <math>\Tau</math> итераций:
<math> \Theta_{k-means}^{d, n} \thicksim O(\Tau*k*d*n) </math>
</div>

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

Рассмотрим информационный граф алгоритма. Алгоритм k means начинается с этапа инициализации, после которого следуют итерации, на каждой из которых выполняется два последовательных шага (см. [[#Схема реализации последовательного алгоритма|"Схема реализации последовательного алгоритма"]]):
* распределение векторов по кластерам
* перерасчет центров кластеров

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

Распределение векторов по кластерам
Информационный граф шага распределения векторов по кластерам представлен на ''рисунке 1''. Исходами данного графа является исходные векторы <math>\mathbf{x}_1, ..., \mathbf{x}_n</math>, а также центры кластеров <math>\mathbf{\mu}_1, ... \mathbf{\mu}_k</math>, вычисленные ранее (на шаге инициализации, если рассматривается первая итерация алгоритма, или на шаге пересчета центров кластеров предыдущей итерации в противном случае). Каждая пара векторов данных <math>\mathbf{x}_i, i=\overline{1,n}</math> и центров кластера <math>\mathbf{\mu}_j, j=\overline{1, k}</math> : (<math>\mathbf{x}_i</math>, <math>\mathbf{\mu}_j</math>) подаются на независимые узлы "d" вычисления расстояния между векторами (более подробная схема вычисления расстояния представлена далее, ''рисунок 2''). Далее узлы вычисления расстояния "d", соответствующие одному и тому же исходному вектору <math>\mathbf{x}_i</math> передаются на один узел "m", где далее происходит вычисление новой метки кластера для каждого вектора <math>\mathbf{x}_i</math> (берется кластер с минимальным результатом вычисления расстояния). На выходе графа выдаются метки кластеров , <math>L_1, ..., L_n</math>, такие что <math>\forall \mathbf{x}_i, i=\overline{1, n}, \mathbf{x}_i \in S_j \Leftrightarrow L_i = j</math>.

[[file:Clusterization.png|thumb|center|800px|Рис. 1. Схема распределения векторов по кластерам. ''d'' – вычисление расстояния между векторами; ''m'' – вычисление минимума.]]

Вычисление расстояния между векторами
Подробная схема вычисления расстояния между векторами <math>\mathbf{x}_i, \mathbf{\mu}_j</math> представлена на ''рисунке 2''. Как показано на графе, узел вычисления расстояния между векторами "d" состоит из шага взятия разности между векторами (узел "<math>-</math>") и взятия нормы получившегося вектора разности (узел "<math>||\cdot||^2</math>"). Более подробно, вычисление расстояния между векторами <math>\mathbf{x}_i = {x_{i1,}, ...,{x_{in}}}, \mathbf{\mu}_j = {\mu_{j1}, ...,\mu_{jn}}</math> может быть представлено как вычисление разности между каждой парой компонент <math>(x_{iz}, \mu_{jz}), z=\overline{1, d}</math> (узел "<math>-</math>"), далее возведение в квадрат для каждого узла "<math>-</math>" (узел "<math>()^2</math>") и суммирования выходов всех узлов "<math>()^2</math>" (узел "<math>+</math>").

[[file:dist_calc.png|thumb|center|800px|Рис. 2. Схема вычисления расстояния между вектором и центром кластера.]]

Пересчет центров кластеров
Информационный граф шага пересчета центров кластеров представлен на ''рисунке 3''. Исходами данного графа является исходные векторы <math>\mathbf{x}_1, ..., \mathbf{x}_n</math>, а также им соответствующие метки кластера, <math>L_1, ..., L_n</math>, такие что <math>\forall x_i, i=\overline{1, n}, \mathbf{x}_i \in S_j \Leftrightarrow L_i = j</math>, вычисленные на этапе распределения векторов по кластерам. Все векторы <math>\mathbf{x}_1, ..., \mathbf{x}_n</math> подаются в узлы <math>+_1, ...+_k</math>, каждый узел <math>+_m, m = \overline{1,k}</math> соответствует операции сложения векторов кластера с номером <math>m</math>. Метки кластера <math>L_1, ..., L_n</math> также совместно передаются на узлы <math>S_m, m = \overline{1,k}</math>, на каждом из которых вычисляется количество векторов в соответствующем кластере (количество меток с соответствующим значением). Далее каждая пара выходов узлов <math>+_m</math> и <math>S_m</math> подается на узел "<math>/</math>", где производится деление суммы векторов кластера на количество элементов в нем. Значения, вычисленные на узлах "<math>/</math>", присваиваются новым центрам кластеров (выходные значения графа).

[[file:Recluster.png|thumb|center|800px|Рис. 3. Схема пересчета центров кластеров]]

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

Работа алгоритма состоит из <math>\Tau</math> итераций, в каждой из которых происходит распределение d-мерных векторов по <math>k</math> кластерам, а также пересчет центров кластеров в d-мерном пространстве. В шаге распределения d-мерных векторов по <math>k</math> кластерам расстояния между вектором и центрами кластеров вычисляются независимо (отсутствуют информационные зависимости). Центры масс кластеров также пересчитываются независимо друг от друга. Таким образом, имеет место [[глоссарий#Массовый параллелизм|''массовый параллелизм'']]. Вычислим параллельную сложность <math>\Psi_*</math> каждого из шагов, а также параллельную сложность всего алгоритма, <math>\Psi_{k-means}</math>. Будем исходить из предположения, что может быть использовано любое необходимое число потоков.


Распределение d-мерных векторов по <math>k</math> кластерам

Поскольку на данном шаге для каждой пары векторов <math>\mathbf{x}_i, i=\overline{1,n}</math> и <math>\mathbf{\mu}_j, j=\overline{1,k}</math> операции вычисления расстояния не зависят друг от друга, они могут выполняться параллельно. Тогда, разделив все вычисление расстояний на <math>n</math> потоков, получим, что в каждом потоке будет выполняться только одна операция вычисления расстояния между векторами размерности d. При этом каждому вычислительному потоку передаются координаты центров всех кластеров <math>\mathbf{\mu}_1, ..., \mathbf{\mu}_k</math>. Таким образом, параллельная сложность данного шага определяется сложностью параллельной операции вычисления расстояния между d-мерными векторами, <math>\Psi_{distance}^d</math> и сложностью определения наиболее близкого кластера (паралельное взятие минимума по расстояниям), <math>\Psi_{min}^k</math>. Для оценки <math>\Psi_{distance}^d</math> воспользуемся [[Нахождение_частных_сумм_элементов_массива_сдваиванием | параллельной реализацией нахождения частичной суммы элементов массива путем сдваивания]]. Аналогично, <math>\Psi_{min}^k = log(k)</math>. В результате, <math>\Psi_{distance}^d = O(log(d))</math>. Таким образом:

<math>\Psi_{distribute}^{k, d} = \Psi_{distance}^d + \Psi_{min}^k = O(log(d))+O(log(k)) = O(log(k*d))</math>

Пересчет центров кластеров в d-мерном пространстве

Поскольку на данном шаге для каждого из <math>k</math> кластеров центр масс может быть вычислен независимо, данные операции могут быть выполнены в отдельных потоках. Таким образом, параллельная сложность данного шага, <math>\Psi_{recenter}^{k, d}</math>, будет определяться параллельной сложностью вычисления одного центра масс кластера размера <math>m</math>, <math>\Psi_{recenter}^{k, d}</math>, а так как <math>m \le n \Rightarrow \Psi_{recenter}^{d, m} \le \Psi_{recenter}^{d, n}</math>. Сложность вычисления центра масс кластера d-мерных векторов размера n аналогично предыдущим вычислениям равна <math>O(log(n))</math>. Тогда:

<math>\Psi_{recenter}^{k, d} \le \Psi_{recenter}^{d, n} = O(log(n))</math>

Общая параллельная сложность алгоритма

На каждой итерации необходимо обновление центров кластеров, которые будут использованы на следующей итерации. Таким образом, итерационный процесс выполняется последовательно<ref>Zhao, Weizhong, Huifang Ma, and Qing He. "Parallel k-means clustering based on mapreduce." IEEE International Conference on Cloud Computing. Springer Berlin Heidelberg, 2009.</ref>. Тогда, поскольку сложность каждой итерации определяется <math>\Psi_{distribute}^{k, d}</math> и <math>\Psi_{recenter}</math>, сложность всего алгоритма, <math>\Psi_{k-means}</math> в предположении, что было сделано <math>\Tau</math> операций определяется выражением

<math>\Psi_{k-means} \approx \Tau * (\Psi_{distribute}^{k, d} + \Psi_{recenter}^{k, d}) \le \Tau * O(log(k*d*n))</math>

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

Входные данные 
<ul>
<li>Матрица из <math>n*d</math> элементов <math>x_{i, j} \in \mathbb{R}, i=\overline{1, n}, j=\overline{1, d}</math>– координат векторов (наблюдений).</li>
<li>Целое положительное число <math>k, k \le n</math> – количество кластеров.</li>
</ul>


Объем входных данных 
<math>1</math> целое число + <math>n*d</math> вещественных чисел (при условии, что координаты – вещественные числа).


Выходные данные 
<math>n</math> целых положительных чисел <math>L_1, ..., L_n</math>– номера кластеров, соотвествующие каждому вектору (при условии, что нумерация кластеров начинается с <math>1</math>).


Объем выходных данных 
<math>n</math> целых положительных чисел.


=== Свойства алгоритма ===
[[глоссарий#Вычислительная мощность|''Вычислительная мощность'']]
Вычислительная мощность алгоритма k means равна <math>\frac{k*d*n*\Tau}{n*d} = k*\Tau </math>, где <math>k</math> – число кластеров, <math>\Tau</math> – число итераций алгоритма.

[[глоссарий#Детерминированность |''Детерминированность'']] и [[глоссарий#Устойчивость |''Устойчивость'']] 
Алгоритм k means является итерационным. Количество итераций алгоритма в общем случае не фиксируется и зависит от начального расположения объектов в пространстве, параметра <math>k</math>, а также от начального приближения центров кластеров, <math>\mu_1, ..., \mu_k</math>. В результате этого может варьироваться результат работы алгоритма. При неудачном выборе начальных параметров итерационный процесс может сойтись к локальному оптимуму<ref>Von Luxburg, Ulrike. Clustering Stability. Now Publishers Inc, 2010.</ref>. По этим причинам алгоритм не является ни детермирированным, ни устойчивым.

Соотношение последовательной и параллельной сложности алгоритма

<math>\frac{\Theta_{k-means}}{\Psi_{k-means}} = \frac{O(\Tau*k*d*n)}{O(\Tau*log(k*d*n))}</math>

Сильные стороны алгоритма:
<ul>
<li>Сравнительно высокая эффективность при простоте реализации</li>
<li>Высокое качество кластеризации</li>
<li>Возможность распараллеливания</li>
<li>Существование множества модификаций</li>
</ul>
Недостатки алгоритма<ref>Ortega, Joaquín Pérez, Ma Del Rocío Boone Rojas, and María J. Somodevilla. "Research issues on K-means Algorithm: An Experimental Trial Using Matlab."</ref>:
<ul>
<li>Количество кластеров является параметром алгоритма</li>
<li>
Чувствительность к начальным условиям
Инициализация центров кластеров в значительной степени влияет на результат кластеризации.
</li>
<li>
Чувствительность к выбросам и шумам
Выбросы, далекие от центров настоящих кластеров, все равно учитываются при вычислении их центров.
</li>
<li>
Возможность сходимости к локальному оптимуму
Итеративный подход не дает гарантии сходимости к оптимальному решению.
</li>
<li>
Использование понятия "среднего"
Алгоритм неприменим к данным, для которых не определено понятие "среднего", например, категориальным данным.
</li>
</ul>

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

Исследование масштабируемости параллельной реализации алгоритма k means проводилось на суперкомпьютере "Ломоносов"<ref name="Lom">Воеводин Вл., Жуматий С., Соболев С., Антонов А., Брызгалов П., Никитенко Д., Стефанов К., Воеводин Вад. Практика суперкомпьютера «Ломоносов» // Открытые системы, 2012, N 7, С. 36-39.</ref> [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета]. Алгоритм реализован на языке C с использованием средств MPI.
Для исследования масштабируемости проводилось множество запусков программы с разным значением параметра (количество векторов для кластеризации), а также с различным числом процессоров. Фиксировались результаты запусков – время работы <math>t</math> и количество произведенных итераций алгоритма <math>\Tau</math>.

Параметры запусков для экспериментальной оценки:
<ul>
<li>Значения количества векторов <math>n</math>: 20'000, 30'000, 50'000, 100'000, 200'000, 300'000, 500'000, 700'000, 1'000'000, 1'500'000, 2'000'000.</li>
<li>Значения количества процессоров <math>p</math>: 1, 8, 16, 32, 64, 128, 160, 192, 224, 256, 288, 320, 352, 384, 416, 448, 480, 512.</li>
<li>Значение количества кластеров <math>k</math>: 100.</li>
<li>Значение размерности векторов <math>d</math>: 10.</li>
</ul>

Для проведения экспериментов были сгенерированы нормально распределенные псевдослучайные данные (с использованием Python библиотеки [http://scikit-learn.org/ scikit-learn]):
<syntaxhighlight lang="python">
from sklearn.datasets import make_classification
X1, Y1 = make_classification(n_features=10, n_redundant=2, n_informative=8,
n_clusters_per_class=1, n_classes=100,
n_samples=2000000)
</syntaxhighlight>

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

[[file:Flops.png|thumb|center|800px|Рис. 4. График производительности реализации алгоритма.]]

[[file:Efficiency.png|thumb|center|800px|Рис. 5. График эффективности реализации алгоритма.]]

Для заданной конфигурации эксперимента (<math>n, d, p, k</math>) и полученных результатов (<math>t, \Tau</math>) производительность и эффективность реализации расчитывались по формулам:

<ul><li><math>Performance = \frac{N_{k-means}^{d, n}}{t}\ \ (FLOPS),</math></li></ul>
где <math>N_{k-means}^{d, n}</math> – точное число операций с плавающей точкой (операции с памятью, а также целочисленные операции не учитывались), вычисленное в соответствие с разделом [[#Последовательная сложность алгоритма| "Последовательная сложность алгоритма"]];


<ul><li><math>Efficiency = \frac{100 * Performance}{Performance_{Peak}^{p}}\ \ (%),</math></li></ul>
где <math>Performance_{Peak}^{p}</math> – пиковая производительность суперкомпьютера при <math>p</math> процессорах, вычисленная согласно спецификациям Intel® XEON® X5670<ref>"http://ark.intel.com/ru/products/47920/Intel-Xeon-Processor-X5670-12M-Cache-2_93-GHz-6_40-GTs-Intel-QPI"</ref>.



В результате экспериментальной оценки были получены следующие оценки эффективности реализации:
<ul>
<li>Минимальное значение: 0.000409 % достигается при <math>n=20'000, p=480</math></li>
<li>Максимальное значение: 0.741119 % достигается при <math>n=300'000, p=1</math></li>
</ul>



Оценки масштабируемости реализации алгоритма k means:
<ul>
<li>По числу процессоров: -0.002683 – эффективность убывает с ростом числа процессоров. Данный результат вызван ростом накладных расходов для обеспечения параллельного выполнения алгоритма.</li>
<li>По размеру задачи: 0.002779 – эффективность растет с ростом числа векторов. Данный результат вызван тем, что при увеличении размера задачи, количество вычислений растет по сравнению с временем, затрачиваемым на пересылку данных.</li>
<li>Общая оценка: -0.000058 – можно сделать вывод, что в целом эффективность реализации незначительно уменьшается с ростом размера задачи и числа процессоров.</li>
</ul>


[https://github.com/serban/kmeans Использованная реализация алгоритма k means]

=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===
==== Открытое программное обеспечение ====
<ol>
<li>[https://www.icpsr.umich.edu/CrimeStat/ CrimeStat]</li> Программное обеспечение, созданное для операционных систем Windows, предоставляющее инструменты статистического и пространственного анализа для решения задачи картирования преступности.
<li>[http://juliastats.github.io Julia]</li> Высокоуровневый высокопроизводительный свободный язык программирования с динамической типизацией, созданный для математических вычислений, содержит реализацию k-means.
<li>[https://mahout.apache.org Mahout]</li> Apache Mahout - Java библиотека для работы с алгоритмами машинного обучения с использованием MapReduce. Содержит реализацию k-means.
<li>[https://www.gnu.org/software/octave/ Octave]</li> Написанная на C++ свободная система для математических вычислений, использующая совместимый с MATLAB язык высокого уровня, содержит реализацию k-means.
<li>[http://spark.apache.org/docs/latest/mllib-clustering.html Spark]</li> Распределенная реализация k-means содержится в библиотеке Mlib для работы с алгоритмами машинного обучения, взаимодействующая с Python библиотекой NumPy и библиотека R.
<li>[http://torch.ch Torch]</li> MATLAB-подобная библиотека для языка программирования Lua с открытым исходным кодом, предоставляет большое количество алгоритмов для глубинного обучения и научных расчётов. Ядро написано на Си, прикладная часть выполняется на LuaJIT, поддерживается распараллеливание вычислений средствами CUDA и OpenMP. Существуют реализации k-means.
<li>[http://www.cs.waikato.ac.nz/ml/weka/ Weka]</li> Cвободное программное обеспечение для анализа данных, написанное на Java. Содержит k-means и x-means.
<li>[http://accord-framework.net/docs/html/T_Accord_MachineLearning_KMeans.htm Accord.NET]</li> C# реализация алгоритмов k-means, k-means++, k-modes.
<li>[http://docs.opencv.org/3.0-beta/doc/py_tutorials/py_ml/py_kmeans/py_kmeans_opencv/py_kmeans_opencv.html OpenCV]</li> Написанная на С++ библиотека, направленная в основном на решение задач компьютерного зрения. Содержит реализацию k-means.
<li>[http://mlpack.org/ MLPACK]</li> Масштабируемая С++ библиотека для работы с алгоритмами машинного обучения, содержит реализацию k-means.
<li>[https://www.scipy.org/ SciPy]</li> Библиотека Python, содержит множество реализаций k-means.
<li>[http://scikit-learn.org/ scikit-learn]</li> Библиотека Python, содержит множество реализаций k-means.
<li>[https://www.r-bloggers.com/k-means-clustering-in-r/ R]</li> Язык программирования для статистической обработки данных и работы с графикой, а также свободная программная среда вычислений с открытым исходным кодом в рамках проекта GNU, содержит три реализации k-means.
<li>[http://elki.dbs.ifi.lmu.de ELKI]</li> Java фреймворк, содержащий реализацию k-means, а также множество других алгоритмов кластеризации.
</ol>
==== Проприетарное программное обеспечение ====

<ol>
<li>[https://www.ayasdi.com/blog/bigdata/topological-data-analysis-of-oil-and-gas-petrophysical-data/ Ayasdi]</li>
<li>[http://www.stata.com/features/cluster-analysis/ Stata]</li>
<li>[http://mathworld.wolfram.com/K-MeansClusteringAlgorithm.html Mathematica]</li>
<li>[http://www.mathworks.com/help/stats/kmeans.html?requestedDomain=www.mathworks.com MATLAB]</li>
<li>[https://support.sas.com/rnd/app/stat/procedures/fastclus.html SAS]</li>
<li>[http://docs.rapidminer.com/studio/operators/modeling/segmentation/k_means.html RapidMiner]</li>
<li>[https://blogs.sap.com/2013/03/28/sap-hana-pal-k-means-algorithm-or-how-to-do-customer-segmentation-for-the-telecommunications-industry/ SAP HANA]</li>
</ol>
== Литература ==
<references />

Обсуждение участника:Бротиковская Данута

2016-11-16T08:11:44Z

Zhum:

п. 2.4

* нужны пояснения к рисункам 4 и 5.

Участник:Parkhomenko/Алгоритм k средних

2016-11-16T08:06:13Z

Zhum:

{{algorithm
| name = Алгоритм k средних
| serial_complexity = <math>O(tnkd)</math>
| input_data = <math>nd</math>
| output_data = <math>n</math>
| pf_height = <math>O(t * \log kdn)</math>
| pf_width = <math>O(kdn)</math>
}}

Основные авторы описания: [[Участник:Parkhomenko|П.А.Пархоменко]] ([[#Общее описание алгоритма|1.1]], [[#Вычислительное ядро алгоритма|1.3]], [[#Последовательная сложность алгоритма|1.6]], [[#Ресурс параллелизма алгоритма|1.8]], [[#Входные и выходные данные алгоритма|1.9]], [[#Свойства алгоритма|1.10]], [[#Масштабируемость алгоритма и его реализации|2.4]]), [[Участник:Ivan.mashonskiy|И.Д.Машонский]] ([[#Математическое описание алгоритма|1.2]], [[#Макроструктура алгоритма|1.4]], [[#Схема реализации последовательного алгоритма|1.5]], [[#Информационный граф|1.7]], [[#Ресурс параллелизма алгоритма|1.8]], [[#Свойства алгоритма|1.10]], [[#Существующие реализации алгоритма|2.7]])
== Свойства и структура алгоритмов ==

=== Общее описание алгоритма ===
Алгоритм k средних (англ. k-means) - один из алгоритмов машинного обучения, решающий задачу кластеризации. Он был изобретен в середине 1950-х математиком Гуго Штейнгаузом<ref>Steinhaus H. (1956). Sur la division des corps materiels en parties. Bull. Acad. Polon. Sci., C1. III vol IV: 801—804.</ref> и Стюартом Ллойдом<ref>Lloyd S. (1957). Least square quantization in PCM’s. Bell Telephone Laboratories Paper.</ref>. Алгоритм стал особо популярным после публикации Маккуина<ref>MacQueen J. (1967). Some methods for classification and analysis of multivariate observations. In Proc. 5th Berkeley Symp. on Math. Statistics and Probability, pages 281—297.</ref>, в которой впервые был использован термин “k-means”.

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

K-means является итерационным алгоритмом, разновидностью EM-алгоритма. Основная идея работы алгоритма заключается в проведении некоторого количества итераций, на каждой из которых происходит пересчет центра масс для каждого кластера, полученного на предыдущей итерации. После этого векторы перераспределяются по кластерам: вектор относится к тому кластеру, расстояние до центра масс которого минимально. Алгоритм завершает работу в том случае, если на очередной итерации центры масс кластеров не изменились.

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

Исходные данные: множество d-мерных векторов (наблюдений) <math>X</math> = <math>\{x_1, x_2, ..., x_n\}</math>, число кластеров <math>k \in \mathbb{N}</math>

В результате работы алгоритма исходное множество векторов <math>X</math> разбивается на <math>k</math> непересекающихся множеств (кластеров) <math>S_1, S_2, ..., S_k</math>, таких что <math>X = {\bigcup \limits _{i = 1}^k S_i} </math> и значение <math>\sum_{i=1}^{k} \sum_{\mathbf x \in S_i} \left\| \mathbf x - \mu_i \right\|^2 </math> — минимально для всех возможных наборов <math>S_1, S_2, ..., S_k</math>.
Под <math>\mu_i</math> здесь подразумевается центр масс векторов из множества <math>S_i</math>.

Первоначальные значения центров масс <math>\mu_1^{(1)}, ..., \mu_k^{(1)}</math> определяются в начале работы алгоритма случайным образом среди векторов множества <math>X</math>.

Алгоритм заключается в попеременном применении двух шагов <ref>MacKay, David (2003). "Chapter 20. An Example Inference Task: Clustering" (PDF). Information Theory, Inference and Learning Algorithms. Cambridge University Press. pp. 284–292.</ref>: '''распределения''' векторов по кластерам и '''обновления''' центров масс каждого кластера

'''Распределение векторов по кластерам''': на данном шаге каждый вектор распределяется в один из кластеров <math>S_i^{(t)}</math>:
::<math>S_i^{(t)} = \big \{ x_p : \big \| x_p - \mu^{(t)}_i \big \|^2 \le \big \| x_p - \mu^{(t)}_j \big \|^2 \ \forall j, 1 \le j \le k \big\},</math>
'''Обновление центров масс''': на данном шаге вычисляются новые центры масс для кластеров, полученных на предыдущем шаге.
::<math>\mu^{(t+1)}_i = \frac{1}{|S^{(t)}_i|} \sum_{x_j \in S^{(t)}_i} x_j </math>

Алгоритм завершается, когда на очередном шаге не происходит изменения центров масс кластеров.

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

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

Для соотнесения вектора к одному из кластеров, необходимо для каждого из N вектора посчитать расстояние до центров масс всех K кластеров. Для нахождения расстояния между двумя d-мерными векторами p и q используется Евклидова метрика: <math>\sqrt{\sum_{k=1}^d (p_k-q_k)^2}</math>

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

Инициализация центров масс кластеров

В начале алгоритма осуществляется инициализация центров масс <math>\mu_1^{(1)}, ..., \mu_k^{(1)}</math>, которая может быть реализована двумя возможными способами <ref>Hamerly, G.; Elkan, C. (2002). "Alternatives to the k-means algorithm that find better clusterings" (PDF). Proceedings of the eleventh international conference on Information and knowledge management (CIKM).</ref>:
* случайный выбор центров масс среди исходных наблюдений <math>x_1, x_2, ..., x_n</math>;
* все наблюдения случайным образом распределяются по кластерам <math>S_1, S_2, ..., S_k</math>, а затем для каждого кластера выполняется операция обновления центра масс.

Распределение векторов по кластерам

На шаге распределения векторов по кластерам производится операция нахождения квадратов расстояний между векторами кластера и центром масс кластера:
::<math>\rho = \big \| x_p - \mu^{(t)}_i \big \|^2</math>

Обновление центров масс кластеров

На шаге обновления центров масс производится операция суммирования векторов кластера:
::<math>\mu^{(t+1)}_i = \frac{1}{|S^{(t)}_i|} \sum_{x_j \in S^{(t)}_i} x_j </math>

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

Последовательность исполнения метода следующая:
# Инициализируются центры масс <math>\mu_1^{(1)}, ..., \mu_k^{(1)}</math>
# <math>t := 1</math>
# Для каждого вектора <math>x_i, i = 1, 2, ..., n</math> вычисляется <math>m = \underset{j \in \{1, 2, ..., k\}} {\operatorname{arg\,min}} \big \| x_i - \mu^{(t)}_j \big \|^2</math>, вектор <math>x_i</math> распределяется в кластер <math>S^{(t)}_m</math>
# Для каждого <math>j = 1, 2, ..., k</math> вычисляется <math>\mu^{(t+1)}_j = \frac{1}{|S^{(t)}_i|} \sum_{x_j \in S^{(t)}_i} x_j </math>
# Если <math>\mu^{(t)}_j = \mu^{(t+1)}_j, j = 1, 2, ..., k</math>, завершить выполнение алгоритма, иначе <math>t := t + 1</math>, переход на шаг 3.

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

Для вычисления центра массы кластера, содержащего <math>n_i</math> d-мерных векторов, необходимо:
* <math>n_i * (d - 1)</math> операций сложения
* <math>d</math> операций деления

Для определения центров масс всех k кластеров требуется:
* <math>n * (d - 1)</math> операций сложения
* <math>k * d</math> операций деления

Для определения расстояния между двумя d-мерными векторами, требуется:
* <math>d</math> операций вычитания
* <math>d</math> операций умножения
* <math>d - 1</math> операций сложения

Для определения кластера для n d-мерного векторов, необходимо:
* <math>n * k * d</math> операций вычитания
* <math>n * k * d</math> операций умножения
* <math>n * k * (d - 1)</math> операций сложения

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

Сложность всего алгоритма, состоящего из <math>t</math> итераций: <math>O(t * n * k * d)</math>

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

В данном разделе описывается информационный граф алгоритма k-средних при <math>n = 3, k = 2</math>

На рисунке 1 показана общая структура алгоритма: в качестве входных данных выступает матрица, строками которой являются входные векторы <math>x_1, x_2, x_3</math>, на выходе получается массив из <math>n</math> чисел, где элемент с номером <math>i = 1, 2, 3</math> обозначает номер кластера, которому принадлежит вектор <math>x_i</math>. На шаге <math>init</math> происходит инициализация значений центров масс кластеров, после этого осуществляется итеративное повторение этапов распределения векторов по кластерам (<math>as</math>) и обновления значений центров масс кластеров (<math>up</math>). Когда на очередном шаге обновления центров масс кластеров значения центров масс не изменяются, алгоритм завершает работу, и в качестве выходных данных выступают номера кластеров для каждого из входных векторов.
[[file:k_means_main.png|thumb|center|400px|Рисунок 1. Общая схема работы алгоритма k-средних]]

'''Распределение векторов по кластерам.''' На рисунке 2 изображен информационный граф для этапа распределения векторов по кластерам. В качестве входных данных выступают строки входной матрицы (входные векторы) <math>x_1, x_2, x_3</math> и текущие значения центров масс кластеров <math>\mu_1, \mu_2</math> (вычисленные на этапе инициализации или предшествующего этапа обновления центров масс кластеров). В качестве выходных данных выступают числа <math>m_1, m_2, m_3</math>, где <math>m_i, i = 1, 2, 3</math> - номер кластера, содержащего вектор <math>x_i</math>. Вершинами с пометкой <math>sub</math> обозначены операции векторной разности, вершинами <math>sn</math> - операция вычисления квадрата нормы вектора, вершинами <math>am</math> - операция <math>\underset{i \in \{1, 2\}} {\operatorname{arg\,min}} p_i</math>.
[[file:k_means_info_graph_as.png|thumb|center|400px|Рисунок 2. Граф алгоритма для этапа распределения векторов по кластерам]]
'''Обновление центров масс кластеров.''' На рисунке 3 представлен информационный граф для этапа обновления центров масс кластеров. В качестве входных данных выступают строки входной матрицы (входные векторы) <math>x_1, x_2, x_3</math> с соответствующими номерами кластеров <math>m_1, m_2, m_3</math>, содержащих эти векторы. В качестве выходных данных здесь выступают обновленные значения центров масс кластеров: <math>\mu_1, \mu_2</math>. Вершинами с пометками <math>s_i, i = 1, 2</math> обозначены операции суммирования векторов, принадлежащих кластеру <math>i</math>. Вершинами с пометками <math>cs_i, i = 1, 2</math> обозначены операции вычисления выражения <math>1 / |S_i|</math>, где за <math>S_i</math> обозначен кластер с номером <math>i</math>. Вершинами с пометкой <math>p</math> обозначена операция произведения.
[[file:k_means_info_graph_up.png|thumb|center|400px|Рисунок 3. Граф алгоритма для этапа обновления центров масс кластеров]]

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

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

В силу особенностей алгоритма k средних порядок выполнения основных этапов существенен, что не позволяет выполнять их параллельно. Таким образом, итоговая сложность параллельного алгоритма будет определяться, исходя из формулы <math>T = t * (T_{as} + T_{up})</math>, где <math>T_{as}</math> - параллельная сложность этапа распределения векторов по кластерам, <math>T_{up}</math> - параллельная сложность этапа обновления центров масс кластеров, <math>t</math> - общее число итераций алгоритма.

Параллельная сложность этапа распределения векторов по кластерам с учетом доступности неограниченного числа процессоров вычисляется следующим образом: так как вычисление значений <math>\big \| x_i - \mu^{(t)}_j \big \|^2</math> для каждой пары векторов <math>x_i, i = 1, 2, ..., n</math> и <math>\mu^{(t)}_j, j = 1, 2, ..., k</math> можно выполнять независимо и для вычисления этого выражения требуется <math>O(\log d)</math> операций в соответствии с [[Нахождение_частных_сумм_элементов_массива_сдваиванием | параллельной реализацией нахождения сумм элементов массива сдваиванием]]. Параллельная сложность реализации операции нахождения минимума из <math>k</math> элементов определяется как <math>O(\log k)</math>. Таким образом, сложность этапа распределения векторов по кластерам <math>O(\log kd)</math>.

Параллельная сложность этапа обновления центров масс кластеров вычисляется следующим образом: так как обновление значений каждого из центров масс кластеров можно выполнять независимо, параллельная сложность определяется сложностью обновления центра масс самого большого кластера. В худшем случае для нахождения значения выражения <math>\mu^{(t+1)}_j = \frac{1}{|S^{(t)}_i|} \sum_{x_j \in S^{(t)}_i} x_j </math> требуется <math>O(\log n)</math> операций.

С учетом вышесказанного, итоговая параллельная сложность алгоритма k средних определяется выражением <math>O(t * \log kdn)</math>.

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

'''Входные данные''':
* целое неотрицательное число <math>k</math> - количество кластеров;
* матрица координат векторов <math>A</math> размерностью <math>n * d</math>.

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

'''Выходные данные''':
* вектор длины <math>n</math> - для каждого вектора указан номер кластера.

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

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

Соотношение последовательной и параллельной сложности алгоритма равно <math>\frac{O(tnkd)}{O(t * \log kdn)}</math>.

Число операций алгоритма k средних оценивается как <math>O(tnkd)</math>, суммарный объем входных и выходных данных равен <math>n(d+1)</math>. Следовательно, вычислительная мощность алгоритма линейна по <math>k</math> и линейна по <math>t</math>.

Стоит отметить следующие ключевые особенности алгоритма k средних:
* Алгоритм прост в реализации и имеет высокую скорость работы по сравнению с другими алгоритмами кластеризации (при удачном выборе начальных значений центров масс кластеров)
* В качестве метрики используется евклидово расстояние, а в качестве меры разброса кластера используется дисперсия
* Количество кластеров k является входным параметром алгоритма, поэтому неправильный выбор этого параметра может негативно повлиять на качество кластеризации
* Сходимость алгоритма к локальному минимуму может породить некорректный конечный результат работы
* Алгоритм очень чувствителен к выбору начальных центров масс кластеров: классический вариант подразумевает случайный их выбор, что может являться источником погрешности. Из этого и предыдущего свойства следует то, что алгоритм не является устойчивым.

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

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

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

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

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

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

=== Масштабируемость алгоритма и его реализации ===
Исследование масштабируемости алгоритма k-means в зависимости от количества используемых процессов было проведено в статье Кумара<ref>Kumar, J., Mills, R. T., Hoffman, F. M., & Hargrove, W. W. (2011). Parallel k-means clustering for quantitative ecoregion delineation using large data sets. Procedia Computer Science, 4, 1602-1611.</ref>. Исследование происходило на суперкомпьютере Jaguar - Cray XT5<ref>https://www.top500.org/system/176029</ref>. На момент экспериментов данный суперкомпьютер имел следующую конфигурацию: 18,688 вычислительных узлов с двумя шестнадцатиядерными процессорами AMD Opteron 2435 (Istanbul) 2.6 GHz, 16 GB of DDR2-800 оперативной памяти, и SeaStar 2+ роутер. Всего он состоял из 224,256 вычислительных ядер, 300 TB памяти, и пиковой производительностью 2.3 petaflops.

Реализация алгоритма была выполнена на языке программирования C с использованием MPI.

Объем данных составлял 84 гигабайта, количество объектов (d-мерных векторов) n равнялось 1,024,767,667, размерность векторов d равнялась 22, количество кластеров k равнялось 1000.

На рисунке 4 показана зависимости времени работы алгоритма кластеризации k-means в зависимости от количества используемых процессоров. Можно отметить, что время, затраченное на чтение данных и запись результатов кластеризации, практически не изменяется с увеличением количества задействованных процессоров. Время же работы самого алгоритма кластеризации уменьшается с увеличением количества процессоров.
[[Файл:k-means-proc-scalability.png|thumb|center|700px|Рисунок 4. Зависимости времени работы алгоритма кластеризации k-means в зависимости от количества используемых процессоров.]]

Ниже представлены результаты исследования времени работы алгоритма k-means в зависимости от количества кластеров k и количества векторов n. Для исследования использовалась реализация k-means на языке программирования C (с использованием OpenMP). Тестирование происходило на 8 процессорах. Затраченное время считалось как среднее арифметическое 5 запусков алгоритма.

На рисунке 5 показана зависимость времени работы алгоритма от количества кластеров k. Количество векторов n равно 100000.
[[Файл:K-means-k.png|thumb|center|700px|Рисунок 5. Зависимости времени работы алгоритма кластеризации k-means в зависимости от количества кластеров k.]]

На рисунке 6 показана зависимость времени работы алгоритма от количества векторов n. Количество кластеров k равно 160.
[[Файл:K-means-n.png|thumb|center|700px|Рисунок 6. Зависимости времени работы алгоритма кластеризации k-means в зависимости от количества векторов n.]]

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

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

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

Существуют следующие реализации алгоритма k-средних:
* [http://scikit-learn.org/ scikit-learn] библиотека машинного обучения для языка Python.
* [https://www.scipy.org/ SciPy] библиотека на языке Python, содержащая большое число реализаций различных алгоритмов, в том числе ''k''-средних.
* [http://elki.dbs.ifi.lmu.de ELKI] библиотека для анализа данных на языке программирования Java, содержит различные алгоритмы кластеризации, в том числе ''k''-средних.
* [http://mlpack.org MLPACK] библиотека машинного обучения для C++, содержит реализацию алгоритма ''k''-средних.
* [https://github.com/JuliaStats/Clustering.jl Julia k-means] реализация алгоритма ''k''-средних на языке программирования Julia.
* [http://opencv.org/ OpenCV] библиотека содержит реализацию ''k''-средних.
* [http://mahout.apache.org Apache Mahout] содержит реализацию алгоритма ''k''-средних на базе MapReduce.
* [http://www.cs.waikato.ac.nz/~ml/weka Weka] библиотека и инструмент для анализа данных на языке Java.
* [http://torch.ch/ Torch] библиотека машинного обучения на базе языка программирования Lua.
* [https://spark.apache.org/ Apache Spark MLlib] содержит распределенную реализацию алгоритма ''k''-средних.
* [http://www.accord-framework.net/ Accord.NET] содержит несколько различных реализаций ''k''-средних на языке C#.
* [https://www.r-bloggers.com/k-means-clustering-in-r/ R k-means] реализация ''k''-средних на языке R.

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

Обсуждение участника:Ivan.mashonskiy

2016-11-16T08:05:52Z

Zhum:

п. 2.4

* нет текста программы
* нужны пояснения к рисункам 5 и 6.

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

2016-11-16T07:57:16Z

Zhum:

п. 2.4

* нет описания или ссылки на аппаратную платформу
* нет окончательного текста программы
[[Участник:Zhum|Zhum]] ([[Обсуждение участника:Zhum|обсуждение]]) 10:57, 16 ноября 2016 (MSK)

Участник:IanaV/Алгоритм k means

2016-11-16T07:57:09Z

Zhum:

{{level-a}}
Авторы страницы: [[Участник:IanaV|Валуйская Я.А.]], [[Участник:GlotovES|Глотов Е.С.]]

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

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

=== Общее описание алгоритма ===
Алгоритм k-means (k средних) - один из наиболее популярных алгоритмов кластеризации. Наиболее простой, но в то же время достаточно неточный метод кластеризации в классической реализации.
Алгоритм был разработан в 1956 году математиком Гуго Штейнгаузом <ref>[http://www.laurent-duval.eu/Documents/Steinhaus_H_1956_j-bull-acad-polon-sci_division_cmp-k-means.pdf Steinhaus H. (1956). Sur la division des corps materiels en parties. Bull. Acad. Polon. Sci., C1. III vol IV: 801—804.]</ref>, и почти одновременно его изобрел Стюарт Ллойд <ref>[http://www-evasion.imag.fr/people/Franck.Hetroy/Teaching/ProjetsImage/2007/Bib/lloyd-1982.pdf Lloyd S. (1957). Least square quantization in PCM’s. Bell Telephone Laboratories Paper.]</ref>. Особую популярность алгоритм снискал после работы Джеймса Маккуина <ref>[https://pdfs.semanticscholar.org/a718/b85520bea702533ca9a5954c33576fd162b0.pdf MacQueen J. (1967). Some methods for classification and analysis of multivariate observations. In Proc. 5th Berkeley Symp. on Math. Statistics and Probability, pages 281—297.]</ref>
Алгоритм кластеризации k-means решает задачу распределения <math>N</math> наблюдений (элементов векторного пространства) на заранее известное число кластеров <math>K</math>. Действие алгоритма таково, что он стремится минимизировать среднеквадратичное отклонение на точках каждого кластера.
Алгоритм k-means является итерационным алгоритмом кластеризации. На каждой итерации происходит пересчет центра масс для каждого кластера, полученного на предыдущем шаге, затем исходные векторы заново распределяются по кластерам в соответствии с тем, какой из новых центров оказался ближе по выбранной метрике. Алгоритм завершается, когда на какой-то итерации не происходит изменения кластеров.

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

''Исходные данные:''
* множество наблюдений <math>X = \{x_1, x_2, ..., x_n\}</math>, где каждое наблюдение <math>x_i \in R^d, i = 1, ..., n</math>;
* количество кластеров <math>k \in N, k \leq n</math>

''Обозначения:''
* <math>S = \{S_1, S_2, ..., S_k \} </math> - множество кластеров, которые удовлетворяют следующим условиям:
** <math>S_i \bigcap S_j = \emptyset, i \neq j</math>;
** <math>X = {\bigcup \limits _{i = 1}^k S_i} </math>.
* <math>\mu_i \in R^d, i = 1, ..., k</math> - центр масс кластера <math>S_i</math>
* <math>d(u, v)</math> - расстояние между векторами <math>u \in R^m, v \in R^m</math>

''Выходные данные:''
* <math>L = (l_1, l_2, ..., l_n)</math> - набор меток, где метка <math>l_i \in N_{[1, k]}</math> - является порядковым номером кластера, к которому принадлежит вектор <math>x_i</math>: <math> x_i \in S_{l_i}</math>

 ''Цель алгоритма k-means'' - распределить наблюдения из входного множества <math>X</math> по <math>k</math> кластерам <math>S = \{S_1, S_2, ..., S_k \} </math> таким образом, чтобы сумма квадратов расстояний от каждой точки кластера до его центра масс по всем кластерам была минимальной:

<math>\arg\min_{S} \sum_{i=1}^{k} \sum_{x \in S_i} (d(x, \mu_i))^2 </math>,

Алгоритм состоит из следующих шагов:

# Инициализация центров масс На данном шаге задаются начальные значения центров масс <math> \mu_1^1, ..., \mu_k^1</math>. Существует несколько способов их выбора. Они будут рассмотрены ниже.
# t-ый шаг итерации:
#* Распределение векторов по кластерам На данном шаге каждый вектор <math>x_i \in X</math> распределяется в свой кластер <math>S_j^t</math> так, что: <math>l_i^t = \arg \min_{j} (d(x_i, \mu_j^t))^2 , j = 1, ..., k; i = 1, ..., n</math>
#* Пересчет центров масс кластеров На данном шаге происходит пересчет центров масс кластеров, полученных на предыдущем этапе: <math>\mu_i^{t+1} = \frac{1}{|S_i^t|} \sum_{x \in S_i^t} x</math>; <math>i = 1, ..., k</math>
# Критерий останова <math>\mu_i^t = \mu_i^{t+1},</math> для всех <math>i = 1, ..., k</math>

Способы инициализации начальных данных:
# Метод Forgy Случайным образом выбираются <math>k</math> векторов из множества наблюдений <math>X</math>. Эти вектора используются в качестве центров масс кластеров <math>\mu_1, ..., \mu_k</math>
# Метод случайного разбиения (Random Partition) <ref>[http://people.csail.mit.edu/tieu/notebook/kmeans/15_p600-hamerly.pdf Hamerly, G.; Elkan, C. (2002). "Alternatives to the k-means algorithm that find better clusterings". Proceedings of the eleventh international conference on Information and knowledge management (CIKM).]</ref> Каждый вектор <math>x_i, i = 1, .., n</math> случайным образом распределяется в кластер <math>S_j, j = 1, .., k</math>, затем для каждого кластера вычисляется его центр масс <math>\mu_j</math>.

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

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

Распределение векторов по кластерам заключается в следующем: для каждого вектора <math>x_i \in X, i = 1, ..., n</math> необходимо посчитать расстояние между этим вектором и центром масс кластера <math>\mu_j^t, j = 1, ..., k</math>. Следовательно, на каждой итерации необходимо выполнить <math>n * k</math> операций вычисления расстояния между векторами.

Пересчет центров масс кластеров заключается в следующем: для каждого кластера <math>S_i^t \in S, i = 1, ..., k</math> необходимо пересчитать кластер по формуле, приведенной в пункте выше. Следовательно, на каждой итерации необходимо выполнить <math>k</math> операций пересчета центров масс кластеров.

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

# Макрооперация "Расстояние между векторами" В данном алгоритме используется Евклидова метрика: <math>v \in R^m</math> и <math>u \in R^m: d(v, u) = \sqrt{\sum_{j=1}^{m} (v_j - u_j)^2} </math>;
# Макрооперация "Пересчет центра масс кластера" <math>\mu_i^{t+1} = \frac{1}{|S_i^t|} \sum_{x \in S_i^t} x</math>

Таким образом, алгоритм в терминах макроопераций выглядит следующим образом:
# Инициализация центров масс Метод Forgy: центры масс <math>\mu_j^1, j = 1, ..., k</math> выбираются случайным образом. Метод случайного разбиения: вектора <math>x_i \in X</math> случайным образом распределяются по кластерам. Для каждого кластера выполняется макрооперация "Пересчет центра масс кластера" для нахождения <math>\mu_j^1</math>.
# t-ый шаг итерации:
#* Распределение векторов по кластерам На данном шаге для каждого вектора <math>x_i \in X</math> k раз выполняется макрооперация "Расстояние между векторами" для нахождения расстояния между <math>x_i</math> и <math>\mu_j^t, j = 1, ..., k</math>. Затем для каждого вектора <math>x_i</math> находится минимальное расстояние.
#* Пересчет центров масс кластеров На данном шаге для каждого кластера выполняется макрооперация "Пересчет центра масс" для нахождения <math>\mu_j^{t+1}</math>.
# Критерий останова <math>\mu_i^t = \mu_i^{t+1},</math> для всех <math>i = 1, ..., k</math>

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

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

Входные данные : Множество векторов <math>X</math>, количество кластеров <math>k</math>
Выходные данные : Набор меток <math>L</math> принадлежности к кластеру
1 Инициализация центров масс <math>\mu_i^1, i = 1, ..., k</math>;
2 t := 1;
3 Для каждого вектора <math>x_i \in X, i = 1, ..., n:</math> <math>l_i^t = \arg \min_{j} (d(x_i,\mu_j^t))^2 , j = 1, ..., k</math>;
4 Для каждого кластера <math>S_i^t, i = 1, ..., k</math> выполняется макрооперация "Пересчет центра масс";
5 if (<math>\exists i = 1, ..., k: \mu_i^t \neq \mu_i^{t+1}</math>) {
6 t := t + 1;
7 goto 3;
8 } else {
9 stop;
10 };

Существующие способы оптимизации алгоритма <ref>[http://link.springer.com/chapter/10.1007/3-540-45643-0_13 Phillips S. J. Acceleration of k-means and related clustering algorithms //Workshop on Algorithm Engineering and Experimentation. – Springer Berlin Heidelberg, 2002. – С. 166-177.]</ref> <ref>[http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.187.3017&rep=rep1&type=pdf Hamerly G. Making k-means Even Faster //SDM. – 2010. – С. 130-140.]</ref> <ref>[http://cseweb.ucsd.edu/~elkan/kmeansicml03.pdf Elkan C. Using the triangle inequality to accelerate k-means //ICML. – 2003. – Т. 3. – С. 147-153.]</ref>

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

Подсчитаем количество операций для каждого шага алгоритма.

# Инициализация:
#* Метод Forgy: <math>N_{init} = 0</math>
#* Метод случайного разбиения:
#** Количество операций деления: <math>N^{/}_{init} = k * d</math>;
#** Количество операций сложения: <math>N^{+}_{init} = d * (n - k)</math>.
# Распределение <math>n</math> векторов <math>x_i \in R^d</math> по <math>k</math> кластерам на одной итерации:
#* Количество операций умножения: <math>N^{*}_{distr} = k * n * d</math>;
#* Количество операций сложения: <math>N^{+}_{distr} = k * n * (d - 1)</math>;
#* Количество операций вычитания: <math>N^{-}_{distr} = k * n * d</math>;
#* Количество операций взятия минимума: <math>N^{min}_{distr} = n * (k - 1)</math>.
# Пересчет центра масс <math>\mu_i \in R^d</math> для <math>k</math> кластеров на одной итерации:
#* Количество операций деления: <math>N^{/}_{update} = k * d</math>;
#* Количество операций сложения: <math>N^{+}_{update} = d * (n - k)</math>.

Следовательно, в случае если алгоритм сошелся за <math>i</math> итераций, получаем:
* Операций сложения/вычитания: <math>N^{+,-}_{k-means} = N^{+}_{init} + i*(N^{+}_{distr} + N^{-}_{distr} + N^{+}_{update}) = d * (n - k) + i*(k*n*(d-1)+k*n*d+d*(n-k)) \thicksim O(i*k*n*d)</math>
* Операций умножения/деления: <math>N^{*,/}_{k-means} = N^{/}_{init} + i*(N^{*}_{distr} + N^{/}_{update}) = k * d + i*(k*n*d+k*d) \thicksim O(i*k*n*d)</math>

Таким образом, [[глоссарий#Последовательная сложность|''последовательная сложность'']] алгоритма k-means для <math>n</math> <math>d</math>-мерных векторов и <math>k</math> кластеров за <math>i</math> итераций, требуемых для сходимости алгоритма: <math>O(i * n * k * d)</math>

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

Рассмотрим информационный граф алгоритма k-means.
На рисунке 1 представлена общая схема алгоритма k-means, согласно разделу [[#Схема реализации последовательного алгоритма|"Схема реализации последовательного алгоритма"]].
Вершина Init - этап инициализации.
Вершина Distribute - этап распределения векторов по кластерам.
Вершина Update - этап пересчета центров масс кластеров.
[[file:k-means-all.PNG|800px|thumb|center|Рисунок 1. Общая схема алгоритма k-means]]

На рисунке 2 представлен информационный граф этапа распределения векторов по кластерам. На вход данному этапу подают множество векторов <math>x_1, x_2, ..., x_n</math> из входных данных и множество центров масс кластеров <math>\mu^t_1, ..., \mu^t_k</math>, полученных с шага инициализации или с предыдущей итерации. Для каждой пары векторов <math>x_i, \mu^t_j, i = 1, ..., n; j = 1,..., k</math> считается расстояние между ними (вершина dist). Информационный граф вычисления расстояния между двумя векторами рассмотрен ниже (рисунок 3). Затем выполняется операция нахождения минимума (вершина min), в результате которой каждому вектору <math>x_i, i = 1, ..., n</math> приписывается метка <math>l^t_i</math>, равная порядковому номеру кластера <math>S^t_j, j = 1 ..., k</math>, которому принадлежит данный вектор: <math>x_i \in S^t_j</math>.
[[file:k-means-distribute.PNG|800px|thumb|center|Рисунок 2. Схема этапа распределения векторов по кластерам]]

На рисунке 3 представлен информационный граф вычисления расстояния между двумя векторами <math>x_i = (x_{i1}, ..., x_{id}), i = 1, ..., n</math> и <math>\mu^t_j = (\mu^t_{j1}, ..., \mu^t_{jd}) , j = 1, ..., k</math>. Выполняется операция поэлементного вычитания двух векторов (вершины -), затем возведение в квадрат (вершины sqr), затем суммирование полученных результатов (вершина +). На выходе получаем квадрат расстояния между векторами.
[[file:K-means-distance.PNG|800px|thumb|center|Рисунок 3. Схема вычисления расстояния между двумя векторами]]

На рисунке 4 представлен информационный граф этапа пересчета центров масс кластеров <math>\mu^t_1, \mu^t_2,..., \mu^t_k</math>. Для каждого кластера <math>S^t_j, j = 1, ..., k</math> выполняется операция суммирования (вершина <math>sum_j</math>) векторов, которые принадлежат данному кластеру. Кроме того, для каждого кластера выполняется операция определения количества элементов в нем (вершина <math>size_j</math>). Затем выполняется операция деления (вершина /). На выходе получаем новые центры масс кластеров <math>\mu^{t+1}_1, \mu^{t+1}_2,..., \mu^{t+1}_k</math>.
[[file:k-means-update.PNG|800px|thumb|center|Рисунок 4. Схема этапа пересчета центров масс кластеров]]

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

Вычислительное ядро алгоритма имеет большие возможности для параллелизма:
* Распределение векторов по кластерам: вектора <math>x_i, x_j, i \neq j; i, j = 1, ..., n</math> могут быть распределены по кластерам независимо друг от друга;
* Пересчет центров масс кластеров: центры масс кластеров <math>\mu_i, \mu_j, i \neq j; i, j = 1, ..., k</math> могут быть пересчитаны независимо друг от друга.

Однако, этап пересчета центров масс кластеров зависит от этапа распределения векторов по кластерам, так что эти этапы должны выполняться строго последовательно. Таким образом, параллельная сложность алгоритма может быть вычислена следующим образом: <math>N_{k-means} = i * (N_{distr} + N_{update})</math>, где <math>i</math> - количество итераций, необходимых для сходимости алгоритма, <math>N_{distr}</math> - параллельная сложность этапа распределения векторов по кластерам, <math>N_{update}</math> - параллельная сложность этапа пересчета центров масс кластеров.

Рассчитаем параллельную сложность <math>N_{distr}</math> этапа распределения векторов по кластерам в предположении наличия неограниченного числа процессоров для одной итерации. Для каждой пары векторов <math>(x_i, \mu_j), i = 1,...,n; j = 1, ..., k</math> операция вычисления расстояния выполняется независимо.
* При выполнении операция вычисления расстояния операции вычитания и умножения выполняются независимо друг от друга, поэтому требуется только одно вычитание и одно умножение. Число операций сложения: <math>N^{+}_{distr} = O(log(d))</math> согласно [[Нахождение_частных_сумм_элементов_массива_сдваиванием | алгоритму нахождения частичной суммы элементов массива путем сдваивания]];
* Для нахождения минимума среди <math>k</math> элементов требуется <math>O(log(k))</math> операций сравнения.
Таким образом, получаем, что <math>N_{distr} = O(log(k*d))</math>

Рассчитаем параллельную сложность <math>N_{update}</math> этапа пересчета центров масс кластеров в предположении наличия неограниченного числа процессоров для одной итерации. Нахождение центра масс <math>\mu_j, j = 1, ..., k</math> кластера <math>S_j</math> может выполняться независимо от нахождения центров масс других кластеров. Таким образом, получаем, что <math>N_{update} \leq O(log(n))</math> в худшем случае, когда почти все векторы находятся в одном кластере.

Итоговая параллельная сложность алгоритма: <math>N_{k-means} \leq i * (log(k*d) + log(n)) \thicksim O(i * log(k*d*n)); i</math> - количество итераций, необходимых для сходимости.

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

Входные данные:
* <math>n</math> векторов <math>x_i \in R^d, i = 1, ..., n</math>;
* число кластеров <math>k \in N_{[1,n]}</math>.

Объем входных данных:
<math>n * d</math> действительных чисел, 1 целое положительное число

Выходные данные:
* вектор меток <math>L \in N^n</math>.

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

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

;Достоинства:
# Алгоритм прозрачный и понятный, за счет чего очень прост в реализации;
# Алгоритм имеет высокую скорость работы в случае выбора оптимальных начальных значений центров масс кластеров.

;Недостатки:
# Число кластеров является входным аргументом алгоритма. Таким образом, некорректный выбор данного параметра может привести к плохим результатам работы алгоритма, поэтому зачастую проводят несколько прогонов алгоритма с разными значениями <math>k</math>, чтобы подобрать оптимальный;
# Алгоритм может сойтись к локальному минимуму (достижение глобального минимума не гарантируется);
# Результат сильно зависит от выбора начальных значений центров масс кластеров. Существует улучшенная версия алгоритма - k-means++ <ref>[http://ilpubs.stanford.edu:8090/778/1/2006-13.pdf Arthur, D.; Vassilvitskii, S. (2007). "k-means++: the advantages of careful seeding". Proceedings of the eighteenth annual ACM-SIAM symposium on Discrete algorithms. Society for Industrial and Applied Mathematics Philadelphia, PA, USA. pp. 1027–1035.]</ref>, которая предлагает свой способ нахождения начальных оптимальных значений центров масс кластеров;
# Чувствительность к выбросам и шумам, так как они учитываются при вычислении центров масс кластеров.

;[[глоссарий#Устойчивость|''Устойчивость'']]: Алгоритм является устойчивым к погрешностям во входных данных, так как при вычислении центров кластеров расстояния между объектами усредняются, что приводит к уменьшению ошибки. Алгоритм также является устойчивым к погрешностям, допускаемых при вычислениях, так как операция сложения на каждой новой итерации выполняется над входными данными.

;Сбалансированность: Множество входных векторов можно равномерно разделить между параллельными вычислителями. Центры всех кластеров можно распространить на все вычислители (так как их заведомо меньше, чем число входных векторов). В таком случае на каждой итерации определение для каждого объекта ближайшего кластера представляет собой вычисление расстояния от каждого входного вектора, находящегося на вычислителе, до каждого кластера, и является сбалансированной операцией. После данного этапа происходит пересчёт центров кластеров. Данная операция является несбалансированной в случаях, когда число объектов в одном из кластеров значительно больше числа объектов в других кластерах, из-за чего один кластер занимает большое число вычислителей, а остальные занимают по одному или несколько вычислителей. В таком случае для данного кластера потребуется вычислить центр [[Нахождение_частных_сумм_элементов_массива_сдваиванием | алгоритмом нахождения частичной суммы элементов массива путем сдваивания]]. Данная операция представляет несбалансированность порядка <math>O(log (k*n))</math>. После данного шага происходит сбалансированная операция рассылки центров кластеров на все вычислители.В идеальном случае параллелизации алгоритм не является сбалансированным, однако в реальных задачах, когда <math>n >> p</math>, где <math>p</math> - количество вычислителей, эта несбалансированность сглаживается наличием объектов из каждого кластера на каждом вычислителе

;Соотношение последовательной и параллельной сложности: <math>{O(n*d*k*i) \over O(log(n*d*k)*i)} \thicksim O \bigg( {n*d*k \over log(n*d*k)} \bigg)</math>

;[[глоссарий#Вычислительная мощность|''Вычислительная мощность'']]: Последовательный алгоритм: <math>{O(n*d*k*i) \over n*d+n+1} \thicksim {O(d*k*i) \over d+1} \thicksim O(k*i)</math>, где <math>n</math> - число входных векторов, <math>d</math> - размерность векторов, <math>k</math> - число кластеров, <math>i</math> - число итераций, требуемое для сходимостиПараллельный алгоритм: <math>O(log(n*d*k)*i) \over n*d+n+1</math>

;[[глоссарий#Детерминированность|''Детерминированность'']]: Алгоритм является недетерминированным, так как результат зависит от выбора исходных центров кластеров, а их оптимальный выбор неизвестен.

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
==== Локальность реализации алгоритма ====
===== Структура обращений в память и качественная оценка локальности =====
===== Количественная оценка локальности =====
=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===
Исследование проводилось на суперкомпьютере "Ломоносов" Суперкомпьютерного комплекса МГУ им. М.В. Ломоносова.

Набор данных для тестирования состоял из 946000 векторов размерности 2 (координаты на сфере)
Набор и границы значений изменяемых параметров запуска реализации алгоритма:

* число процессов (виртуальных ядер) [8 : 512];
* число кластеров [128 : 384].
В результате проведённых экспериментов был получен следующий диапазон эффективности реализации алгоритма:

* минимальная эффективность реализации <math>2,47%</math> достигается при делении исходных данных на 128 кластеров с использованием 512 процессов;
* максимальная эффективность реализации <math>7,13%</math> достигается при делении исходных данных на 352 кластера с использованием 8 процессов.
На следующих рисунках приведены графики производительности и эффективности выбранной реализации k means в зависимости от изменяемых параметров запуска.
[[file:kmeans_performance.jpg|thumb|center|720px|Рисунок 5. Параллельная реализация k means. Максимальная производительность. ]]
[[file:kmeans_efficiency.jpg|thumb|center|720px|Рисунок 6. Параллельная реализация k means. Максимальная эффективность. ]]
Исследовалась [https://github.com/serban/kmeans параллельная реализация алгоритма k means]. Для вычисления производительности в неё был вписан код на MPI, реализующий подсчёт числа операций с плавающей точкой.
Были получены следующие оценки масштабируемости реализации алгоритма k means:
*По числу процессов: <math>-0.02209</math>. Следовательно, с ростом числа процессов эффективность уменьшается.
*По размеру задачи: <math>0.01252</math>. Следовательно, с ростом размера задачи (числа кластеров) эффективность увеличивается.
*Общая оценка: <math>-0.00081</math>. Таким образом, с ростом и размера задачи, и числа процессов эффективность уменьшается.

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

Существуют следующие Open Source реализации алгоритма:
* [http://elki.dbs.ifi.lmu.de/ ELKI] - содержит реализацию алгоритма k-means на языке Java (в том числе реализацию улучшенного алгоритма k-means++)
* [http://www.cs.waikato.ac.nz/~ml/weka/ Weka] - содержит реализацию k-means на языке Java
* [http://mahout.apache.org/ Apache Mahout] - содержит реализацию k-means в парадигме MapReduce
* [https://spark.apache.org/ Spark Mllib] - содержит распределенную реализацию k-means
* [http://accord-framework.net/ Accord.NET] - содержит реализацию k-means на C# (в том числе реализацию улучшенного алгоритма k-means++)
* [https://github.com/mlpack/mlpack MLPACK] - содержит реализацию k-means на языке C++
* [http://opencv.org/ OpenCV] - содержит реализацию k-means на C++. А также есть обертки для языков Python и Java
* [https://www.scipy.org/ SciPy] - содержит реализацию k-means на языке Python
* [http://scikit-learn.org/ Scikit-learn] - содержит реализацию k-means на языке Python
* [http://julialang.org/ Julia] - содержит реализацию алгоритма k-means на языке Julia
* [https://www.gnu.org/software/octave/ Octave] - содержит реализацию k-means на языке Octave
* [https://www.r-project.org/ R] - содержит реализацию k-means на языке R
* [http://torch.ch/ Torch] - содержит реализацию k-means на языке Lua

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

Участник:Guryanovak/Алгоритм кластеризации, основанный на минимальном остовном дереве

2016-11-16T07:45:08Z

Zhum:

Авторы описания: [[Участник:guryanovak|Гурьянов Алексей Константинович]], [[Участник:Валерия Кибитова|Кибитова Валерия Николаевна]]

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

{{algorithm
| name = Алгоритм кластеризации, основанный на минимальном остовном дереве
| serial_complexity = <math>O(N^2 \log_2 N)</math>
| input_data = <math> O(Nm) </math>
| output_data = <math> O(N) </math>
}}

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

== Общее описание алгоритма ==
Данный алгоритм решает задачу кластеризации. Кластеризация – это задача разбиения множества объектов на не пересекающиеся подмножества, называемые кластерами таким образом, что объекты в одном кластере были более похожи (в каком-либо смысле) друг на друга, а объекты в разных кластерах существенно отличались.

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

Проблема нахождения минимального остовного дерева, а также ее решение было предложено Борувка в 1926 году. Идея использовать минимальное остовное дерево для кластеризации впервые была предложена Zahn в 1971<ref>Zahn C. T. Graph-theoretical methods for detecting and describing gestalt clusters //IEEE Transactions on computers. – 1971. – Т. 100. – №. 1. – С. 68-86.</ref>, в последующие годы данная идея развивалась такими учеными как: Asano, Bhattacharya, Keil, и Yao<ref>Asano T. et al. Clustering algorithms based on minimum and maximum spanning trees //Proceedings of the fourth annual symposium on Computational geometry. – ACM, 1988. – С. 252-257.</ref>, Avis<ref>Avis D. Diameter partitioning //Discrete & Computational Geometry. – 1986. – Т. 1. – №. 3. – С. 265-276.</ref>, Eldershaw и Hegland<ref>Eldershaw C., Hegland M. Cluster analysis using triangulation //Computational Techniques and Applications. – 1997. – С. 201-208.</ref>, Paivinen и другими<ref>Grygorash O., Zhou Y., Jorgensen Z. Minimum spanning tree based clustering algorithms //2006 18th IEEE International Conference on Tools with Artificial Intelligence (ICTAI'06). – IEEE, 2006. – С. 73-81.</ref>.

Основная идея алгоритма состоит из следующих шагов:

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

2. Построение минимального остовного дерева.
Для этого можно использовать следующие алгоритмы:
*алгоритм Крускала;
*алгоритм Прима;
*алгоритм Борувки.

3. Выделение кластеров.
В минимальном остовном дереве, выбирается <math>k-1</math> ребро (где <math>k</math> – это заранее определенное число кластеров), имеющие наибольшой вес. Выбранные ребра удаляются. Оставшиеся k компонент связности считаются кластерами.

В данной статье алгоритм будет описываться с использованием алгоритма Борувки. Подробное описание которого можно найти пройдя по ссылке [[https://algowiki-project.org/ru/Алгоритм_Борувки Алгоритм Борувки]]

Общая идея его состоит в следующем:
#Изначально каждая вершина графа — тривиальное дерево, а ребра не принадлежат никакому дереву.
#Для каждого дерева найдем минимальное по весу инцидентное ему ребро. Добавим все такие ребра.
#Повторяем шаг 2 пока в графе не останется только одно дерево.

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

На вход алгоритму подается набор <math>N</math> векторов размерности <math>m</math> : <math>(a_{i,1}, a_{i,2}, ..., a_{i,m})</math>, где <math> a_j \in \mathbb {R} \quad \forall j \in [1,m], i \in [1..N] </math> и количество кластеров <math>K</math>, на которые необходимо разбить множество точек.

На выход алгоритм должен вывести <math>N</math> чисел от <math>1</math> до <math>K</math>, показывающих принадлежность входных векторов кластерам.

=== Основные обозначения ===

* <math>E</math> - множество рёбер.
* <math>V</math> - множество вершин.
* <math>G = (V,E) </math> - неориентированный граф, заданный множеством вершин <math>V</math> и множеством рёбер <math>E</math>
* <math>MST(G)</math> (Minimum Spanning Tree) - минимальное остовное дерево графа <math></math>. Остовное дерево — ациклический связный подграф данного связного неориентированного графа, в который входят все его вершины. Минимальное остовное дерево в связанном взвешенном неориентированном графе — это остовное дерево этого графа, имеющее минимальный возможный вес, где под весом дерева понимается сумма весов входящих в него рёбер.

=== Функция веса ===

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

В данной статье будет рассматриваться евклидова метрика:
* <math> | x , y | = \sqrt{\sum_i^m (x_i - y_i)^2} </math>

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

Работу алгоритма можно разделить на три блока:
*1: Вычисление расстояний между вершинами и заполнение данных о компонентах связности
*2: Построение минимального основного дерева
*3: Разделение на K кластеров

Из них основное время работы алгоритма занимают блоки 1 и 2.

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

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

Для описания алгоритма вводятся следующие макрооперации:
*1: getDistance – находит расстояние между двумя вершинами графа как расстояние между соответствующими им точками пространства. (Сложность – <math>O(m)</math>)
*2: initializeComponents – инициализирует состояние класса Components информацией о вершинах и ребрах. В каждую исходную компоненту связности входит одна вершина. (Сложность – <math>O(N^2)</math>)
*3: findMinimalOutgoingEdge – находит ребро c наименьшей длиной, исходящее из заданной компоненты связности. (Cложность – <math>O(N)</math>)
*4: findComp – возвращает индекс компоненты связности в которой находится вершина (Cложность – <math>O(1)</math>)
*5: connectComponentsWithEdge – соединяет две компоненты связности, связанные поданным на вход ребром. Объединение компонент включает в себя замену ребер инцидентности новой компоненты на минимальные ребра из пары объединяемых компонент. (Сложность – <math>O(N)</math>)

Макрооперации 2-5 относятся к последовательной реализации [[Алгоритм Борувки|алгоритма Борувки]], который был выбран как основа вычислительного ядра алгоритма.

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

Схема работы алгоритма была создана с учетом последующей параллельной реализации,<ref>Chung S., Condon A. Parallel implementation of Bouvka's minimum spanning tree algorithm //Parallel Processing Symposium, 1996., Proceedings of IPPS'96, The 10th International. – IEEE, 1996. – С. 302-308.</ref>

<source lang="cpp">
int N; // Размер входных данных
int number_of_clusters; // Число кластеров
int size = N*N; // Размер матрицы инцидентности
Node nodes[N]; // Вершины(точки), заданные начальными условиями
Edge edges[size]; // Все расстояния между вершинами
vector<Edge> tree; // Рёбра минимального остовного дерева
Components comps; // Структура компонент связности
read_data(&nodes, file_name); // Считывание начальных данных

//----------------Вычисление расстояний между вершинами----------------//
for(int i = 0; i < N-1; i++) {
for(int j = i+1; j < N; j++) {
double distance = getDistance(node[i], node[j]); // Вычисление расстояний между вершинами
edges[i*N + j] = Edge(i,j,distance); // Запись значения расстояния в массив
edges[j*N + i] = Edge(i,j,distance); // Запись значения расстояния в массив
}
}

//----------------Заполнение данных о компонентах связности--------------//
initializeComponents(&comps, nodes, edges);

//----------------Построение минимального основного дерева--------------//
while(comps.size > 1) {
vector<edges> mstedges;
for component in comps {
edge e = findMinimalOutgoingEdge(component, comps, edges) // Нахождение минимального ребра инцидентного данной компоненте
mstedges.add(e)
}
for mstedge in mstedges {
if (findComp(comps, mstedge.first) != findComp(comps, mstedge.second)) {
connectComponentsWithEdge(comps, mstedge) // Объединение двух компонент
tree.add(mstedge) // Добавление ребра в минимальное основное дерево
}
}
}

//-----------------------Разделение на K кластеров--------------------------//
sort(tree)
for(int i = tree.size() - 1; i > tree.size() - 1 - number_of_clusters; i--) {
remove_edge(tree, i); // Удаление самых длинных рёбер из MST - формирование кластеров
}
write_data(tree); // Запись выходных данных
</source>

== Последовательная сложность алгоритма ==
Среди выделенных в описании частей алгоритма, самую большую сложность для оценивания временной сложности вызывает часть 3, являющаяся реализацией алгоритма Борувки. Однако если заметить, что после выполнения каждого тела внешнего цикла количество компонент связности будет уменьшаться как минимум вдвое (так как одно ребро в списке ребер минимального основного дерева может повториться максимум двое), то можно сделать вывод, что сложность в худшем случае этого блока алгоритма является <math> O (N^2 \log_2 N) </math>.

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

<math> TC(N, m) = O(N^2m) + O(N^2) + O(N^2 \log_2 N) + O(N \log_2 N) = O(N^2 (m + \log_2 N)) </math>

Если посчитать размерность пространства входных точек за константу при расчете сложности, то временная сложность выразится как

<math> TC(N, m) = O(N^2 \log_2 N) </math>

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

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

[[Файл:InformationGraph-2-8.png|frame|center|alt=Алгоритм| Информационный граф параллельного алгоритма кластеризации на основе алгоритма Борувки]]

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

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

Основная особенность алгоритма построения минимального основного дерева Борувки состоит в том, что основной блок этого алгоритма, нахождения минимального ребра, инцидентного заданной вершине, можно проводить независимо. Это позволяет провести вычисления в ярусе, ответственном за поиск кратчайших ребер за <math>O(1)</math> времени при наличии как минимум <math>N^3</math> процессоров. Процесс обновления информации о компонентах связности, который заключается в обновлении индексов кластеров вершин и в обновлении расстояний между кластерами, можно представить в виде независимой последовательности операций взятия минимума и операций присваивания в количестве <math>O(N)</math> штук (количество компонент связности), что позволит выполнить ярус, ответственный за обновление структуры компонент связности за <math>O(1)</math> при наличие как минимум <math>2N</math> процессоров. Это значит, что каждый ярус будет выполняться за <math> O(1) </math> времени, и аналогично последовательному алгоритму Борувки, после выполнения 2 ярусов количество компонент связности уменьшится минимум вдвое, что гарантирует то, что за время выполнения алгоритма повторится не более чем <math> 4 * \log_2 N </math> ярусов. Учитывая ярусы, посвященные считыванию ввода, вычислению расстояний между точками пространства, удалению <math>K-1</math> ребер из минимального опорного дерева и выводу ответа, итоговую параллельная сложность алгоритма можно оценить как <math> 2 * \log_2 N + 5</math>.

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

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

=== Входные данные алгоритма ===
На вход алгоритму подается набор <math>N</math> векторов размерности <math>m</math> : <math>(a_{i,1}, a_{i,2}, ..., a_{i,m})</math>, где <math> a_j \in \mathbb {R} \quad \forall j \in [1,m], i \in [1..N] </math> и количество кластеров <math>K</math>, на которые необходимо разбить множество точек. Общий объем входных данных можно оценить как <math>O(Nm)</math>.

Если оценивать размерность пространства входных точек константой, то объем входных данных можно оценить как <math>O(N)</math>.

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

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

Соотношение последовательной и параллельной сложности алгоритма равно <math> \frac{N^2 \log_2 N} {\log_2 N} = N^2 </math>.

Вычислительную мощность алгоритма можно оценить как <math> \frac {N^2 \log_2 N} {N} = N \log_2 N</math>.

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

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

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

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

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

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

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

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

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

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

Существующих реализаций алгоритма кластеризации в настоящий момент немного. Ниже приводится список некоторых из них:
*[https://github.com/jakevdp/mst_clustering MST Clustering Python]
Однако существует множество реализаций алгоритма поиска минимального остовного дерева, на основе которых можно реализовать алгоритм кластеризации.
*[https://github.com/umarali/boruvka-mst-parallel Parallel Implementation of Borůvka's MST Algorithm ]
*[http://www.mlpack.org/docs/mlpack-2.0.2/doxygen.php?doc=namespacemlpack_1_1emst.html С++ mlpack MST Algorithm ]
*[https://github.com/nastra/algorithms-java Java Graph Algorithms]
*[http://jgrapht.org/javadoc/org/jgrapht/alg/KruskalMinimumSpanningTree.html Kruskal Java MST Algorithm ]
*[http://jgrapht.org/javadoc/org/jgrapht/alg/PrimMinimumSpanningTree.html Prim Java MST Algorithm ]
*[https://github.com/dineshappavoo/GraphMinimumSpanningTree Java Graph Minimum Spanning Tree ]
*[https://pypi.python.org/pypi/PyAlgDat Python PyAlgDat ]
*[https://networkx.github.io/documentation/networkx-1.10/reference/algorithms.mst.html Python NetworkX Minimum Spanning Tree]
*[http://www.boost.org/doc/libs/1_53_0/libs/graph_parallel/doc/html/dehne_gotz_min_spanning_tree.html C++ Boost Minimum Spanning Tree]

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

<references \>

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

2016-11-16T07:44:56Z

Zhum: Содержимое страницы заменено на «п. 2.4 отсутствует ~~~~»

п. 2.4 отсутствует
[[Участник:Zhum|Zhum]] ([[Обсуждение участника:Zhum|обсуждение]]) 10:44, 16 ноября 2016 (MSK)

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

2016-11-16T07:43:42Z

Zhum:

п. 2.4

* нет текста программы
* нет полного описания аппаратной платформы (ОС, размер памяти)
* нет пояснений к графику

Участник:Tereshinvs/MST Clusterization

2016-11-16T07:43:38Z

Zhum:

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

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

Постановка задачи также может различаться характером входных данных:
# Набор признаков <math> V = \left\{ v_1, v_2, \ldots, v_N \right\} </math> в некотором метрическом пространстве с метрикой <math> \rho(x, y) </math>
# Матрица отношений между объектами: симметричная матрица вещественных чисел размером <math> N \times N </math> с неотрицательными элементами с нулевой диагональю.

В данной статье рассматривается постановка с известным количеством кластеров <math> K </math>.

В данной статье рассматривается алгоритм алгоритм кластеризации на основе MST (Minimum spanning tree — минимальное остовное дерево).

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

Общая схема алгоритма:
# Построение минимального остовного дерева одним из известных методов (алгоритмы Крускала, Прима, Борувки и их комбинации; наиболее пригодным для параллельного исполнения считается алгоритм Борувки)
# Удаление <math> K-1 </math> самых длинных рёбер из минимального остовного дерева.

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

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

=== Математическое описание алгоритма ===
Пусть <math>V</math> — множество объектов, <math>Y</math> — множество номеров (имён, меток) кластеров. Задана функция расстояния между объектами <math>\rho(x,y)</math>. Требуется разбить выборку на непересекающиеся подмножества, называемые ''кластерами'', так, чтобы каждый кластер состоял из объектов, близких по метрике <math>\rho</math>, а объекты разных кластеров существенно отличались. При этом каждому объекту <math>v_i\in V</math>
приписывается номер кластера <math>y_i</math>.

''Алгоритм кластеризации'' — это функция <math>a\colon V\to Y</math>, которая любому объекту <math>v\in V</math> ставит в соответствие номер кластера <math>y\in Y</math>. Множество <math>Y</math> в некоторых случаях известно заранее, однако чаще ставится задача определить оптимальное число кластеров, с точки зрения того или иного ''критерия качества'' кластеризации.

В данном случае задачу можно сформулировать так: выбрать пороговое значение веса ребра <math>W</math>, так чтобы объекты, соединённые ребром весом меньше <math>W</math> лежали в одном кластере, а соединённые ребром весом больше <math>W</math> — в разных.

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

=== Макроструктура алгоритма ===
Основной алгоритм можно разделить на следующие части:
# Нахождение для каждой вершины наименьшего ребра, инциндентного ней
# Добавление найденных наименьших вершин в MST
# "Склейка" компонент связности MST
# Нахождение веса <math>W_{K-1}</math> <math>(K-1)</math>-ого наибольшего ребра
# Удаление рёбер весом не меньше чем <math>W_{K-1}</math>.
=== Схема реализации последовательного алгоритма ===
<source lang="text" line start="0" highlight="1,9">
Ввод: граф V

Поместить каждую вершину в отдельное дерево леса T
Пока в T больше одной компоненты связности:
Для каждой компоненты C из T:
S — пустое множество рёбер
Для каждой вершины v в C:
Найти кратчайшее ребро с одним концом v, а другим не из C, и поместить его в S
Добавить кратчайшее ребро из S в T
Объединить компоненты связности
T — MST

Найти W — вес (K-1)-ого максимального ребра в T
Удалить из T рёбра с весом большим или равным W

Пронумеровать компоненты связности

Вывод: номера компонент связности для каждой вершины
</source>

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

# Нахождение ребер наименьшего веса для всех компонент связности требует <math>O(V)</math> операций на каждом шаге, где <math>V</math> — число рёбер в графе.
# Добавление новых рёбер в MST требует <math>O(N)</math> операций за всё время работы алгоритма.
# При использовании структуры данных система непересекающихся множеств с ранговой эвристикой, объединение деревьев требует примерно , где <math>O(N)</math> операций.
# Доказано, что количество шагов алгоритма <math>O(\log N)</math>.

Итого <math>O(V \log N)</math> операций. При использовании триангуляции Делонэ в некоторых случаях <math>V</math> имеет тот же порядок, что и <math>N</math>, поэтому общая сложность <math>O(N \log N)</math>. В общем же случае сложность составляет <math>O(N^2 \log N)</math>

Удаление <math>K-1</math> рёбер можно осуществить за <math>O(N)</math> операций.

Итак, общая сложность алгоритма в общем случае <math>O(N^2 \log N)</math>.

=== Информационный граф ===
[[File:Tereshinvs_mst_scheme.png|frame|center|alt=Информационный граф|Информационный граф алгоритма кластеризации на основе минимального остовного дерева]]

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

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

Узким местом является нахождение k-ой порядковой статистики для выделения кластеров, а так же объединение компонент связности. Но всего объединений компонент связности <math>N-1</math>, поэтому при его реализации с помощью структуры данных система непересекабщихся множеств с ранговой эвристикой общая сложность за всё время работы алгоритма будет близко к <math>O(N)</math>.
=== Входные и выходные данные алгоритма ===
Входными данными являются число <math> N </math> (количество элементов рассматриваемого множества) и матрица вещественных чисел размера <math> N \times N </math> отношений между элементами этого множества. Матрица предполагается симметричной, а её диагональные элементы равными нулю, поэтому её размер можно оценить как <math> \tfrac{N(N-1)}{2} </math>.

Кроме того, имеется натуральное число <math> K \leqslant N </math> — требуемое количество кластеров.

Выходными данными являются <math> N </math> натуральных чисел от <math> 1 </math> до <math> K </math> — номера кластеров, в которые определена каждая вершина. При этом, каждый кластер содержит хотя бы одну вершину.
=== Свойства алгоритма ===
Отрицательной сторой алгоритмов кластеризации, основанных на минимальных остовных деревьях, является их чувствительность к выбросам. С другой стороны, эти алгоритмы способны выделять кластеры произвольной формы, а результат их применения интуитивно понятен.

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

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

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

=== Возможные способы и особенности параллельной реализации алгоритма ===
С использованием библиотеки Boost::graph::distributed программу можно реализовать следующим образом (указана только часть построения MST):

<source lang="C++" line start="0" highlight="1,9">
#include <boost/graph/use_mpi.hpp>
#include <boost/graph/distributed/mpi_process_group.hpp>
#include <boost/graph/distributed/adjacency_list.hpp>
#include <boost/graph/distributed/dehne_gotz_min_spanning_tree.hpp>
#include <boost/graph/distributed/vertex_list_adaptor.hpp>
#include <boost/graph/metis.hpp>

#include <iostream>
#include <fstream>
#include <vector>

typedef boost::adjacency_list<
boost::listS,
boost::distributedS<
boost::graph::distributed::mpi_process_group,
boost::vecS
>,
boost::undirectedS,
boost::no_property,
boost::property<
boost::edge_weight_t,
float
>
> Graph;

typedef boost::graph_traits<Graph>::edge_descriptor Edge;

int main(int argc, char* argv[])
{
boost::mpi::environment env(argc, argv);

std::ifstream in("big.graph");
boost::graph::metis_reader reader(in);

Graph graph(
reader.begin(), reader.end(),
reader.weight_begin(),
reader.num_vertices()
);

typedef boost::property_map<Graph, boost::edge_weight_t>::type WeightMap;
WeightMap weight_map = boost::get(boost::edge_weight, graph);

std::vector<Edge> mst_edges;

boost::graph::distributed::dense_boruvka_minimum_spanning_tree(
boost::graph::make_vertex_list_adaptor(graph),
weight_map,
std::back_inserter(mst_edges)
);

if (process_id(graph.process_group()) == 0)
std::cout << "Finished" << std::endl;
}
</source>

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

=== Масштабируемость алгоритма и его реализации ===
В этом параграфе описывается масштабируемость параллельной реализации алгоритма из библиотеки Boost::graph::distributed.

К сожалению, не удалось запустить программу, использующую данную библиотеку на суперкомпьютере IBM BlueGene/P, поэтому замеры производительности производились на хилом процессоре Intel Core i5 4210U с двумя ядрами и четырьмя потоками.

[[File:boost_mst_time.png|frame|center|alt=Время работы|Время работы алгоритма построения MST на полном графе из 5000 вершин]]

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

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

=== Существующие реализации алгоритма ===
Библиотека шаблонов для С++ Boost предлагает прямую параллельную реализацию алгоритма Борувки в компоненте graph/distributed. Кроме этого, в ней имеются реализации других алгоритмов построения MST, а также много других параллельных алгоритмов на графах. Библиотека основана на технологии MPI. IBM предоставил патч для Boost 1.47.0 для её использования с компиляторами IBM CL C/C++.

Кроме этой библиотеки не существует распространённой библиотеки, реализующей параллельный алгоритм построения минимального остовного дерева. Но имеется достаточно большое количество библиотек, реализующих однопоточное построение MST:
* JGraphT для Java
* SciPy MST
* множество любительских реализаций, который можно легко найти в интернете по запросу "mst algorithm".

== Литература ==
# Нейский И.М. Классификация и сравнение методов кластеризации, http://it-claim.ru/Persons/Neyskiy/Article2_Neiskiy.pdf
# Minimum spanning tree, https://en.wikipedia.org/wiki/Minimum_spanning_tree
# Алгоритм Борувки, https://en.wikipedia.org/wiki/Bor%C5%AFvka%27s_algorithm
# Euclidean minimum spanning tree, https://en.wikipedia.org/wiki/Euclidean_minimum_spanning_tree
# Система непересекающихся множеств, http://e-maxx.ru/algo/dsu
# Boost Library, http://www.boost.org/
# Параллельное построение MST в библиотеке Boost, http://www.boost.org/doc/libs/1_55_0/libs/graph_parallel/doc/html/dehne_gotz_min_spanning_tree.html#id14
# Патч Boost 1.47.0 для IBM CL C/C++, http://www-01.ibm.com/support/docview.wss?uid=swg27027469

Участник:Sarseev/Алгоритм кластеризации, основанный на минимальном покрывающем дереве

2016-11-16T07:30:51Z

Zhum:

'''Автор''': Арсеев С. П., группа 620

== Свойства и структура алгоритма ==
=== Общее описание алгоритма ===
Данный алгоритм нацелен на решение задачи кластеризации, то есть, разделения множества объектов на группы, называемые кластерами, так, чтобы внутри одного кластера оказались наиболее похожие (по некоторой метрике) друг на друга объекты, а объекты из разных кластеров как можно сильнее отличались друг от друга.
Сам алгоритм состоит из следующих шагов:
# Сведение набора объектов к графу. Объекты становятся вершинами графа, и каждые две вершины соединяются ребром, длина которого равняется расстоянию между этими объектами по некоторой метрике. Выбор метрики зависит от предметной области и желаемых свойств алгоритма. Например, метрикой может служить евклидово расстояние.
# Построение минимального покрывающего (остовного) дерева в этом графе. Более подробно этот шаг описан в [[Построение_минимального_остовного_дерева_(MST)|соответствующей статье]].
# Кластеризация путём удаления некоторого количества рёбер в этом дереве. В случае, если заранее известно количество кластеров <math>k</math>, достаточно удалить <math>k-1</math> ребро с наибольшей длиной, чтобы получить <math>k</math> связных компонент, которые объявляются кластерами. Если же количество кластеров заранее не известно, удаляются рёбра с длиной больше некоторого порога, задаваемого как параметр алгоритма. Возможны и более сложные стратегии выбора рёбер для отсечения.
=== Математическое описание алгоритма ===
На вход алгоритму подаётся <math>n</math> объектов <math>a</math>, которые нужно кластеризовать. Каждый такой объект можно рассматривать как вектор или элемент некоторого метрического пространства. На пространстве, которому принадлежат <math>a</math>, задана метрика <math>d_{ij}=d(a_i,a_j)</math>. 
Первый шаг алгоритма строит граф <math>G=(V,E)</math>, где <math>V</math> - множество вершин графа <math>(|V|=n)</math>, а <math>E</math> - множество его рёбер <math>(|E| = \frac{n*(n-1)}{2})</math>. 
На втором этапе строится минимальное покрывающее дерево <math>MST(G)</math>. После удаления рёбер дерево распадается на поддеревья <math>MST_i</math>. Вершины, входящие в <math>i</math>-е поддерево, объявляются принадлежащими кластеру с номером <math>i</math>.
=== Вычислительное ядро алгоритма ===
Алгоритм состоит из трёх этапов:
# Преобразование исходных данных. Сложность <math>O(n^2)</math>.
# Поиск минимального покрывающего дерева. Последовательная сложность всех трёх основных алгоритмов ([[Алгоритм_Борувки|Борувки]], [[Алгоритм_Крускала|Крускала]] и [[Алгоритм_Прима|Прима]]) <math>O(|E|*log(|E|)) = O(n^2*log(n^2))</math>.
# Разбиение на кластеры. Вычислительная сложность <math>O(n)</math> для простых стратегий разбиения.
Таким образом, вычислительным ядром алгоритма является алгоритм построения минимального покрывающего дерева, поскольку он имеет наибольшую сложность. Стратегии распараллеливания алгоритма основаны на распараллеливании алгоритма построения минимального покрывающего дерева.
=== Макроструктура алгоритма ===
В состав алгоритма входит алгоритм [[Построение_минимального_остовного_дерева_(MST)|построения минимального покрывающего дерева]], являющийся его вычислительным ядром. Также в отдельную часть можно выделить алгоритм разбиения получившегося покрывающего дерева на кластеры.
=== Схема реализации последовательного алгоритма ===
Описание алгоритма на псевдокоде:
<source lang=cpp>
MST_Cluster(object[n] objects){
g = Pairs(objects, metric);
mst = Create_MST(graph);
parts = Split_MST(mst);
for i in range(parts){
clusters[i] = parts[i].vertices;
}
return clusters
}

</source>
=== Последовательная сложность алгоритма ===
Последовательная сложность алгоритма определяется самой сложной его частью (см. пункт 1.3) и равна <math>O(n^2*log(n^2))</math>.
=== Информационный граф ===
[[Файл:MST_cluster.png|thumb|center|1043px|Информационный граф алгоритма. Показана последовательная реализация (большой прямоугольник) и схема распараллеливания алгоритма построения минимального покрывающего дерева.]]
=== Ресурс параллелизма алгоритма ===
Ресурс параллелизма алгоритма основан на свойстве ассоциативности рёбер: 
Пусть <math>MSF(E)</math> – минимальный остовный лес (множество покрывающих деревьев) графа с рёбрами <math>E</math>. Тогда
:<math>
MSF(E_1 \cup E_2 \cup \dots \cup E_k) = MSF(MSF(E_1) \cup MSF(E_2) \cup \dots \cup MSF(E_k)).
</math>

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

Сложность параллельного алгоритма зависит от соотношения объёма входных данных и числа процессов. Существуют распределённые алгоритмы построения минимального покрывающего дерева, имеющие асимптотическую сложность <math>O(n*log(n))</math>. Эта же оценка будет выполняться и для всего алгоритма кластеризации.

=== Входные и выходные данные алгоритма ===
На вход алгоритму подаются объекты <math>(o_1, o_2, ..., o_n)</math>. 
Выходом алгоритма является множество непересекающихся кластеров: <math>C=(C_1, C_2, ..., C_k); C_i = (o_{i,1}, o_{i,2}, ..., o_{i, n_i}); o(i, l) \ne o(j, m); i \ne j; \forall l, m; \sum{n_i} = n </math>.
=== Свойства алгоритма ===
Важным свойством алгоритма является то, что при его распараллеливании по описанной выше стратегии важно правильно выбирать количество процессов. При увеличении количества процессов возрастают затраты на фазу слияния деревьев, полученных каждым процессом: растёт число этапов, в которые производится слияние, а следовательно, возрастают затраты на коммуникацию между процессами, и распределение нагрузки становится более неравномерным из-за того, что часть процессов должна проделать значительно большее количество работы по слиянию деревьев. 
Вычислительная мощность алгоритма имеет порядок <math>O(n*log(n^2))</math>. 
Ещё одним важным свойством алгоритма является его детерминированность в том случае, если для данного набора векторов существует единственное минимальное покрывающее дерево: при использовании детерминированной стратегии разбиения его на поддеревья алгоритм получает единственный результат для каждого набора данных. Однако, время работы может отличаться в зависимости от начального распределения рёбер по процессам.
== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===
[[Файл:MST_cluster_time.png|thumb|center|600px|Время работы алгоритма в зависимости от числа процессов и размера получающегося графа.]]
На графике на логарифмической шкале показана зависимость времени работы алгоритма от числа процессов. Приведены измерения для трёх наборов данных, различающихся размером получаюшегося графа: 4, 8 и 30 миллиардов рёбер соответственно. Как видно из графика, при большом объёме данных алгоритм хорошо масштабируется. Однако, существует предел возможностей распараллеливания: если количество процессов будет сопоставимо с размером набора данных (не показано на графике), время работы может начать расти с увеличением количества процессов, потому что ускорение за счёт распараллеливания будет нивелироваться возрастающими затратами на обмен данными между процессами.
=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===
Основным вычислительным ядром алгоритма является алгоритм построения минимального покрывающего (остовного) дерева, применяющийся для многих задач, и многие библиотеки ограничиваются его реализацией, без реализации основанного на нём алгоритма кластеризации. Примеры реализаций алгоритмов построения MST:
* С++: [http://www.boost.org/doc/libs/1_62_0/libs/graph/doc/ Boost graph library] (алгоритмы Борувки и Крускала)
* C++, MPI: [http://www.boost.org/doc/libs/1_62_0/libs/graph_parallel/doc/html/index.html Parallel boost graph library] (алгоритм Борувки)
* Java: [http://jgrapht.org/ JGraphT] (алгоритмы Крускала и Прима)
* Python: [http://docs.scipy.org/doc/scipy-0.15.1/reference/index.html SciPy]
== Литература ==
# Нейский И.М. Классификация и сравнение методов кластеризации 
# C. Kingsford. Minimum Spanning Trees & Clustering ([https://www.cs.umd.edu/class/fall2009/cmsc451/lectures/Lec07a-mst.pdf])
# Y. Zhou et al. Clustering with Minimum Spanning Trees

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

2016-11-16T07:30:36Z

Zhum:

п 2.4

* нет описания аппаратной платформы
* нет текста программы
* нет указания на реализацию алгоритма (своя или сторонняя)
* зависимость от размера графа неочевидна, переделайте в зависимость от числа входных точек
* число точек на графике довольно мало, поэтому вывести чёткую зависимость можно весьма условно
[[Участник:Zhum|Zhum]] ([[Обсуждение участника:Zhum|обсуждение]]) 10:30, 16 ноября 2016 (MSK)

Участник:SenderovichNikita/Алгоритм кластеризации, основанный на построении каркаса

2016-11-16T07:25:32Z

Zhum:

{{algorithm
| name = MST-Кластеризация
| serial_complexity = <math>O(N^2\log N)</math>
| pf_height = <math>O(\log N)</math>
| pf_width = <math>O(N^2)</math>
| input_data = <math>O(N)</math>
| output_data = <math>O(N)</math>
}}

Автор статьи: [[Участник:SenderovichNikita|Сендерович Никита Леонидович]]

Данный документ содержит описание алгоритма кластеризации, основанного на построении [[Построение минимального остовного дерева (MST)|минимального остовного дерева]] (каркаса, остова, кратчайшего незамкнутого пути, минимального покрывающего дерева, англ. Minimum Spanning Tree (MST)) - эвристического графового алгоритма построения разбиения множества объектов на такие непересекающиеся подмножества объектов, что объекты, принадлежащие одному подмножеству, схожи по заданной метрике в большей степени, чем объекты, принадлежащие разным группам.

Как и все алгоритмы кластеризации, данный алгоритм может быть применён для решения задач кластерного анализа, выделения типовых и нетипичных объектов в рассматриваемой выборке объектов. Его достоинствами по сравнению с другими аналогичными алгоритмами машинного обучения являются наглядность, идейная простота, возможность контролировать число кластеров. Главным недостатком является ограниченная применимость: алгоритм лучше всего подходит для выделения кластеров типа сгущений или лент, наличие разреженного фона или узких перемычек между кластерами может приводить к неадекватному с точки зрения аналитика результату<ref>[http://www.ccas.ru/voron/download/Clustering.pdf Воронцов К.В. "Лекции по алгоритмам кластеризации и многомерного шкалирования"]</ref>. Другим недостатком является высокая вычислительная сложность: на выборках более 100 тыс. объектов без применения параллельных вычислений применить алгоритм невозможно. Рассмотрению соответствующих параллельных алгоритмов и посвящена данная статья.

== Свойства и структура алгоритма ==
=== Общее описание алгоритма ===
Рассматривается выборка <math>X = \{x_i\}, i = 1, 2, \ldots, N</math>, состоящая из <math>N</math> объектов с заданной симметричной неотрицательной функцией расстояния <math>\rho</math>. Данную выборку можно рассматривать как связный неориентированный взвешенный граф <math>G</math>, множество вершин которого совпадает со множеством объектов выборки, веса рёбер соответствуют значениям функции расстояния между соответствующими вершинами.

Также должно быть задано искомое число кластеров <math>K</math>. [[file:MSTClusteringFull.png|thumb|700px|Рис.1. Ключевая идея алгоритма кластеризации на основе построения остовного дерева, разбиение на 3 кластера]]

Идея рассматриваемого алгоритма кластеризации очень проста:
* с помощью какого-либо алгоритма на определённом выше графе строится [[Построение минимального остовного дерева (MST)| минимальное остовное дерево]]
* из полученного дерева выбрасывается <math>K - 1</math> ребро с наибольшими весами, что приводит к появлению в остовном дереве <math>K</math> компонент связности, каждая из которых объявляется кластером

Иллюстрация работы алгоритма приведена на рис. 1. В данном случае рассматриваются 13 объектов на евклидовой плоскости, построено остовное дерево, после чего из него выброшены 2 наиболее длинных ребра и получены три кластера.

Существуют различные модификации описанного алгоритма, связанные с другим алгоритмом конструирования исходного графа или условием выбрасывания рёбер из построенного остовного дерева. Например, число <math>K</math> может быть полезно определить не изначально, а подобрать, рассматривая отсортированную по убыванию последовательность весов рёбер в остовном дереве: если имеется резкое уменьшение весов, то можно удалить все рёбра до него. Формализацией такого подхода является алгоритм ZEMST<ref>[http://www4.ncsu.edu/~zjorgen/ictai06.pdf Minimum Spanning Tree Based Clustering Algorithms]</ref>. Однако в дальнейшем ограничимся анализом определённого выше простейшего варианта.

=== Математическое описание алгоритма ===
Пусть задан связный неориентированный граф на множестве объектов <math>G = (X, E)</math> с неотрицательными весами рёбер <math>\rho(e) = \rho(x_i, x_j) \geqslant 0</math>.

Наиболее частый используемый на практике сценарий следующий:
* каждый объект описывается <math>d</math>-мерным вектором в пространстве
* используется функция расстояния <math>\ell_p</math>

Например, случай, когда в качестве метрики выбирается евклидова метрика <math>\ell_2</math> в литературе называется EMST - Euclidean Minimum Spanning Tree.

Хотя в некоторых задачах возможна ситуация, когда данный граф не является полным (по каким-то причинам определены не все расстояния между вершинами), но в описанных типовых случаях граф является полным, содержит <math>\frac{N(N - 1)}{2} = O(N^2)</math> рёбер.

==== Обзор алгоритмов поиска минимального остова ====
Для поиска минимального остовного дерева на практике используется следующие три похожих друг на друга алгоритма и их комбинации:
* [[Алгоритм Прима]]<ref>Prim, R C. “Shortest Connection Networks and Some Generalizations.” Bell System Technical Journal 36, no. 6 (November 1957): 1389–1401. doi:10.1002/j.1538-7305.1957.tb01515.x.</ref>

* [[Алгоритм Крускала]]<ref>Kruskal, Joseph B. “On the Shortest Spanning Subtree of a Graph and the Traveling Salesman Problem.” Proceedings of the American Mathematical Society 7, no. 1 (January 1956): 48–50. doi:10.1090/S0002-9939-1956-0078686-7.</ref>

* [[Алгоритм Борувки]]<ref>Borůvka, Otakar. “O Jistém Problému Minimálním.” Práce Moravské Přírodovědecké Společnosti III, no. 3 (1926): 37–58.</ref>

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

'''В алгоритме Прима''' рассматривается текущее остовное дерево <math>T</math>. Изначально <math>T</math> состоит из одной вершины, выбранной произвольно. Далее на каждом шаге отыскивается минимальное ребро, ровно один из концов которого принадлежит <math>T</math>, оно добавляется в <math>T</math> вместе со вторым своим концом. Алгоритм завершается через <math>N - 1</math> шаг - ровно столько рёбер в дереве на <math>N</math> вершинах. Последовательная реализация, при которой минимальное ребро на каждом шаге ищется полным перебором рёбер, исходящих из <math>T</math>, имеет сложность <math>O(N^3)</math> на полном графе. Алгоритм можно ускорить, если поддерживать двоичное дерево поиска по рёбрам, ровно один из концов которых принадлежит <math>T</math>. Тогда при добавлении очередной вершины в <math>T</math> необходимо добавить в двоичное дерево не более чем <math>N - 1</math> новое ребро за <math>O(N \log N)</math>, а выбор минимума осуществляется за <math>O(\log N)</math>. Поскольку шаг добавления вершины повторяется <math>N</math> раз, итоговая сложность <math>O(N^2 \log N)</math>.

'''В алгоритме Крускала''' остов <math>T</math> изначально пуст, и в остов на каждом шаге добавляется вместе со своими концами минимальное ребро, имеющееся в графе, не нарушающее свойства ацикличности уже выбранного на предыдущих шагах леса <math>T</math>. Через <math>N - 1</math> шаг лес <math>T</math> гарантированно станет связным деревом. Если искать минимум полным перебором по <math>O(N^2)</math> рёбрам полного графа, сложность получится <math>O(N^3)</math>. Если же предварительно отсортировать все рёбра по весу за <math>O(N^2 \log N^2) = O(N^2 \log N)</math>, то дальше все рёбра искомого остова можно будет добавить в процессе одного прохода по этому массиву рёбер в порядке возрастания весов - для каждого ребра проверяем, не нарушает ли оно свойство ацикличности <math>T</math> и добавляем его в <math>T</math>, если не нарушает. Для того чтобы быстро проверять свойство принадлежности обоих концов ребра одной из компонент <math>T</math>, используется эффективная структура данных - система непересекающихся множеств<ref>[http://e-maxx.ru/algo/dsu Система непересекающихся множеств]</ref>. Сложность одной такой проверки <math>O(\alpha(N))</math>, где <math>\alpha(N)</math> - обратная функция Аккермана, значение которой не превосходит 4 для <math>N \leqslant 10^{500}</math>. Итоговая сложность такого алгоритма равна сложности сортировки и также составляет <math>O(N^2 \log N)</math>.

'''В алгориме Борувки''', как и в алгоритме Крускала, поддерживается лес <math>T</math>. Изначально лес состоит из <math>N</math> изолированных вершин графа. На каждом шаге путём перебора всех рёбер графа для каждого дерева в <math>T</math> ищется минимальное ребро, ровно один конец которого принадлежит этому дереву. После этого все найденные рёбра добавляются в <math>T</math>. Поскольку после каждой итерации число деревьев в лесе <math>T</math>, исходно равное <math>N</math>, уменьшается не менее чем в 2 раза, таких шагов будет произведено не более <math>\log N</math>, поэтому итоговая сложность алгоритма составляет <math>O(N^2\log N)</math>.

==== Анализ ресурса параллелизма алгоритмов поиска минимального остова ====
Итак, каждый из данных алгоритмов имеет сложность <math>O(N^2\log N)</math>, однако с точки зрения параллельной реализации они различаются. Эффективные реализации алгоритмов Прима и Крускала используют структуры данных, рассчитанные на последовательный характер алгоритма. Так, двоичное дерево поиска, содержащее все рёбра, исходящие из построенного на данный момент остова <math>T</math>, трудно приспособить к распределённым архитектурам. А при работе с полным графом с большим числом вершин хранить его становится практически невозможно. В алгоритме Крускала можно распараллелить этап сортировки рёбер, но на последнем шаге алгоритма необходимо последовательно просмотреть отсортированный массив <math>O(N^2)</math> рёбер, поддерживая СНМ, что сводит на нет параллелизм. Таким образом, для этих двух алгоритмов необходима существенная переработка для получения эффективного параллельного решения <ref>[http://www.cslab.ntua.gr/~knikas/files/papers/mtaap12kruskal.pdf An approach to parallelize Kruskal's algorithm using Helper Threads]</ref>.

На этом фоне выгодно выделяется исторически первый алгоритм Борувки. Он был разработан чешским учёным Отакаром Борувкой в 1926 году для решения задачи построения оптимальной электрической сети в Моравии. Он эффективнее всего использует тат факт, что остовные деревья сперва можно найти для отдельных частей графа, после чего объединить полученные деревья. Далее будем рассматривать именно этот метод для построения минимального остовного дерева в алгоритме кластеризации.

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

=== Макроструктура алгоритма ===
Основными элементами алгоритма, которые дальше будут использоваться, являются следующие процедуры:
* вычисление расстояния <math>\rho(x_i, x_j)</math> между объектами (вершинами полного графа)
* функции для работы с графом - инициализация добавление, удаление ребра
* использование упомянутого выше алгоритма СНМ (система непересекающихся множеств) для поддержки компонент связности: можно объединять компоненты при добавлении ребра и проверять принадлежность двух вершин одной компоненте за <math>O(1)</math> (функции ''компонента'', ''обновить_компоненты'')
* процедура сравнения рёбер: рёбра сравниваются по весу, а при равенстве весов по идентификатору ребра. Это важная составная часть алгоритма Борувки, поскольку иначе на этапе добавления рёбер могут возникнуть циклы. Простейшим примером является граф из трёх вершин, все попарные расстояния между которыми равны 1: если по ходу работы для первой окажется ближайшей вторая, для второй третья, а для третьей первая, то в граф будет добавлен цикл.
* сортировка массива рёбер по их весу

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

Алгоритм Борувки поиска минимального остовного дерева в полном графе
<source lang="text" line start="1">
Вход: Выборка объектов X размера N
Выход: рёбра минимального остовного дерева T
Алгоритм:
T := пустое множество рёбер
инициализировать компоненты числами от 1 до N
есть_разные_компоненты = 1
Пока (есть_разные_компоненты == 1):
есть_разные_компоненты = 0
инициализировать массив D кратчайших рёбер, исходящих из компонент, бесконечно длинными рёбрами
цикл по всем парам вершин (x, y) из X:
если компонента(x) не равно компонента(y):
есть разные компоненты = 1
d = расстояние(x, y)
если (ребро (x, y) < ребро D(компонента(x))):
D(компонента(x)) = (x, y)
если (ребро (x, y) < ребро D(компонента(y))):
D(компонента(y)) = (x, y)
цикл по рёбрам E из D:
обновить_компоненты(E)
добавить E в множество T
вернуть Т
</source>

Итоговый алгоритм кластеризации:
<source lang="text" line start="1">
Вход: Выборка объектов X, число кластеров K
Выход: метки кластеров для каждого объекта из X
Алгоритм:
T := рёбра минимального остовного дерева для набора объектов X
E := отсортировать рёбра T по убыванию
цикл по первым K рёбрам в E:
удалить ребро из T
цикл по вершинам v из T:
компоненты[v] = компонента(v)
вернуть компоненты
</source>

=== Последовательная сложность алгоритма ===
В разделе "Обзор алгоритмов поиска минимального остова" уже было показано, что алгоритм Борувки поиска остова имеет сложность <math>O(N^2 \log N)</math>: поскольку на каждом шаге число компонент уменьшается не менее чем в 2 раза, цикл ''while'' выполнится не более <math>\log N</math> раз. Внутри цикла находятся:
* инициализация массива D кратчайших рёбер, исходящих из компонент связности, бесконечностями - <math>O(N)</math>
* перебор по всем рёбрам полного графа и обновление содержимого ячеек массива D - <math>O(N^2)</math>
* добавление найденных рёбер из массива D в граф <math>T</math> - <math>O(N)</math>
* обновление компонент связности в графе <math>T</math> - <math>O(N)</math>

После поиска остова рёбра остовного дерева сортируются за <math>O(N \log N)</math> операций, за <math>O(N)</math> производится выбрасывание рёбер, за <math>O(N)</math> определяются финальные метки кластеров.

Итоговая сложность <math>O(N^2 \log N)</math> операций. В ходе работы основными являются операции сравнения и обращения в память. Обратим внимание, что "узким местом" алгоритма является перебор по всем рёбрам для нахождения минимальных рёбер, исходящих из каждой компоненты связности остовного леса <math>T</math>.

=== Информационный граф ===
Приведём информационный граф, оставив за скобками детали реализации последних шагов алгоритма - сортировки и выбрасывания рёбер:
[[file:InformationGraph.png|thumb|center|700px|Рис.2. Информационная структура алгоритма кластеризации, основанного на поиске минимального остовного дерева]]

Кратко опишем шаги схемы. Для вычисления массива D необходимо обработать некоторые из перебираемых рёбер (конкретные связи зависят от структуры текущего остовного дерева <math>T</math>), поэтому на этом этапе присутствует нерегулярность по данным; кроме того необходима инициализация массива D. Операции обновления структуры остовного графа независимы, могут быть распараллелены и склеены в шаг 3. Алгоритм сортировки теоретически имеет высоту ярусно-параллельной формы <math>O(\log N)</math>. Независимо могут быть выполнены и последние этапы алгоритма, связанные с выбрасыванием рёбер и получением финального ответа, хотя на практике это не так уж важно.

=== Ресурс параллелизма алгоритма ===
Как показал анализ сложности узким местом является нахождение минимальных рёбер, исходящих из каждой компоненты связности остовного леса <math>T</math>. Информационный граф говорит о том, что этот этап можно эффективно распаралелить, так как выбор минимального исходящего ребра для каждой компоненты связности остовного дерева и даже для каждой вершины может исполнятся независимо. Таким образом <math>O(N^2)</math> рёбер - ширина ярусно-параллельной формы алгоритма. Процедуры инициализации массива D, добавления найденных рёбер в граф могут быть произведены независимо по элементам. Параллельно может быть проведена и сортировка, и выбрасывание рёбер в конце, хотя это не так принципиально в реальности. Но это позволяет говорить, что высота ярусно-параллельной формы имеет порядок <math>O(\log N)</math>.

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

=== Входные и выходные данные алгоритма ===
Входными данными алгоритма является описание выборки из <math>N</math> объектов. В типовом случае каждый из них описывается <math>d</math> координатами, однако может описываться каким-то иным способом, позволяющим находить расстояния между объектами. Также на вход передаётся число искомых кластеров <math>K</math>.

Выходом является массив из <math>N</math> целых чисел от 1 до <math>K</math> - номера кластеров, найденных алгоритмом кластеризации.

=== Свойства алгоритма ===
Известно, что минимальное остовное дерево определено однозначно, если в графе все рёбра различны. Очень важно ввести операцию сравнения рёбер и добиться, чтобы все рёбра были различны. Пример, когда алгоритм Борувки зацикливается из-за этого, приведён выше.

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

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

Параллельная реализация алгоритма MST:
* C++, MPI: [http://www.boost.org/libs/graph_parallel/doc/html/index.html Parallel Boost Graph Library]; функции <code>[http://www.boost.org/libs/graph_parallel/doc/html/dehne_gotz_min_spanning_tree.html#dense-boruvka-minimum-spanning-tree dense_boruvka_minimum_spanning_tree]</code>, <code>[http://www.boost.org/libs/graph_parallel/doc/html/dehne_gotz_min_spanning_tree.html#boruvka-then-merge boruvka_then_merge]</code>, <code>[http://www.boost.org/libs/graph_parallel/doc/html/dehne_gotz_min_spanning_tree.html#boruvka-mixed-merge boruvka_mixed_merge]</code> сочетают [[алгоритм Борувки]] и [[алгоритм Крускала]].

Последовательные реализации доступны во многих библиотеках:
* [https://networkx.github.io/documentation/networkx-1.9/_modules/networkx/algorithms/mst.html NetworkX MST] - реализация в библиотеке для работы с графами на Python
* [http://www.boost.org/doc/libs/1_38_0/libs/graph/doc/prim_minimum_spanning_tree.html Алгоритм Прима], [http://www.boost.org/doc/libs/1_62_0/libs/graph/doc/kruskal_min_spanning_tree.html Алгоритм Крускала] - C++ реализация в boost
* [http://jgrapht.org/javadoc/org/jgrapht/alg/PrimMinimumSpanningTree.html Алгоритм Прима], [http://jgrapht.org/javadoc/org/jgrapht/alg/KruskalMinimumSpanningTree.html Алгоритм Крускала] - Java реализация в JGraphT

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

<references />

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

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

2016-11-16T07:25:22Z

Zhum:

п. 2.4 не заполнен.
[[Участник:Zhum|Zhum]] ([[Обсуждение участника:Zhum|обсуждение]]) 10:25, 16 ноября 2016 (MSK)

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

2016-11-16T07:24:20Z

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{(a_1-b_1)^2+(a_2-b_2)^2+\dots+(a_P-b_P)^2} = \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> целых чисел.

=== Свойства алгоритма ===
[[глоссарий#Вычислительная мощность|''Вычислительная мощность'']]
Вычислительная мощность алгоритма k means равна <math>\frac{K*N^2*\Tau}{N^2} = K*\Tau </math>, где <math>K</math> – число кластеров, <math>\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>

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

Исследование проводилось на суперкомпьютере '''"Ломоносов"'''. Алгоритм реализован с использованием технологии '''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 />

Участник:Astandrik/Алгоритм кластеризации, основанный на минимальном остовном дереве

2016-11-16T07:24:01Z

Zhum:

{{algorithm
| name = Алгоритм кластеризации, основанный на минимальном остовном дереве
| serial_complexity = <math> O(N^2 log(N)) </math>
| pf_height = <math> O(log(N)) </math>
| pf_width = <math> O(N) </math>
| input_data = <math> N </math>
| output_data = <math> N </math>
}}

Основные авторы описания: [[Участник:Astandrik|Стандрик Антон Сергеевич]]

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

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

Данный алгоритм предназначен для решения задач кластеризации. Говоря в общем, кластеризация — многомерная статистическая процедура, выполняющая сбор данных, содержащих информацию о выборке объектов, и затем упорядочивающая объекты в сравнительно однородные группы <ref>Классификация и кластер. Под ред. Дж. Вэн Райзина. М.: Мир, 1980. 390 с.</ref>.

Впервые идея использования минимального остовного дерева для кластеризации данных была преждожена C. T. Zah в 1971 году<ref name=zakh>C. T. Zahn, “graph-Theriotical methos for detecting and describing getalt clusters,” IEEE Trans. Computers, vol. 20, no. 1, pp. 68-86, 1971 </ref>. Этот метод широко используется исследователями при анализе изображений <ref>Y. Xu, V. Olman and E. C. Uberbacher, “A mentation using minimum spanning trees,” Image and Vission Computing, vol. 15, pp. 47-57,1997.</ref><ref>Zhi Min Wang, Yeng Chai Soh, Qing Song, Kang Sim, “Adaptive spatial information-theoretic clustering for image segmentation,” Pattern Recognition, vol. 42, no. 9, pp. 2029-2044, 2009.</ref>, а также при анализе биологических данных <ref>Y. Xu, V. Olman and D. Xu, “Clustering gene expression data using a graph-Theriotic approach: An application of minimum spanning trees,” Bioinformatics, vol. 18, no. 4, pp. 536-545, 2002.</ref>.

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

# Разбиение входных векторов на пары и вычисление расстояний в них. Для этого небходим выбор метрики пространства, в котором осуществляется кластерный анализ. В качестве примеров метрик можно привести:
#* Метрика Евклида: <math>d_{ij} = \sqrt{\sum^n_{k=1}(x_{ik} - x_{jk})^2}</math>
#* Метрика city-block (манхэттенская метрика): <math>d_{ij} = \sum^n_{k=1}|x_{ik} - x_{jk}| </math>
#* Метрика Брея-Картиса: <math>d_{ij} = \sum^n_{k=1}\frac{|x_{ik} - x_{jk}|}{|x_{ik} + x_{jk}| }</math>
# Построение минимального остовного дерева по заданному множеству. Существует три основных алгоритма [[Построение минимального остовного дерева (MST) | построения минимального остовного дерева]]:
#* [[Алгоритм Прима]]
#* [[Алгоритм Крускала]]
#* [[Алгоритм Борувки]]
# Разделение полученного дерева на несвязное множество поддеревьев в соответствии с некоторой стратегией. Можно выделить три популярные стратегии кластеризации:
#* SEMST<ref>Asano, M.K.T., Bhattacharya, B., Yao, F.: Clustering algorithms based on minimum and maximum spanning trees. In: In Proceedings of the fourth annual symposium on Computational Geometry. (1998) 252–257</ref> (standard Euclidean minimum spanning tree clustering algorithm) - предполагается, что нам заранее известно число кластеров. В таком случае, если число кластеров равно <math>k</math>, то из полученного в первом пункте остовного дерева удаляются <math>k-1</math> связей с наибольшим весом.
#* CEMST<ref>Ye, B., Chao, K.M.: Spanning Trees and Optimization Problems. Chapman and
Hall (2004)</ref>(The maximum cost minimum spanning tree) - Работает так же как и SEMST, однако вместо веса вершины используется её стоимость, которая вычисляется следующим образом: Пусть ребро <math>e = (x_{i}, x_{j})</math>, тогда <math>cost(e) = w(e) * degree(x_{i}) * degree(x_{j})</math>. Далее, зная число кластеров <math>k</math> и стоимости рёбер, удаляются <math>k-1</math> рёбер с максимальной стоимостью.
#* ZEMST<ref name=zakh /> (The Zahn’s minimum spanning tree) - от двух предыдущих эта стратегия отличается тем, что здесь число кластеров не известно заранее, а вычисляется в процессе кластеризации. Его суть в том, что удаляются те рёбра, веса которых значительно превосходят средний вес ребра в соседних поддеревьях.

==== Достоинства ====

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

[[File:Selection_117_.png|frame|center|alt=Point-connected clusters| Слева направо: Рисунок 1: Начальные данные. Рисунок 2: построенное минимальное остовное дерево. Рисунок 3: разбиение на кластеры путём удаления самых длинных связей.]]

==== Недостатки ====

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

Кроме того, существуют наборы данных, на которых популярные алгоритмы (SEMST, CEMST, ZEMST) не дают правильного результата, и для которых требуется применение более сложных алгоритмов, к числу которых можно отнести, например, алгоритм HEMST <ref>Clustering with Minimum Spanning Trees Yan Zhou, Oleksandr Grygorash, Thomas F. Hain, Meador Inge Zach Jorgensen School of Computer and Information Sciences University of South Alabama, Mobile, AL 36688 USA Urban Insight Inc. 5657 Wilshire Blvd Ste 290, Los Angeles, CA 90036</ref> с временем работы <math>O(n^2 * log(n))</math>.

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

[[File:Selection_116_.png|frame|center|alt=Point-connected clusters| Правильное разбиение на два кластера.]]

[[File:Selection_115_.png|frame|center|alt=Point-connected clusters| Неверное разбиение на один кластер.]]

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

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

Исходные данные: набор векторов размерности <math>n</math> : <math>(a_1, a_2, ..., a_n)</math>, где <math> a_j \in \mathbb {R} \quad \forall j \in [1,n] </math>.

Вычисляемые данные: Сгруппированные по кластерам данные.

==== Основные обозначения ====

* <math>E</math> - множество рёбер.
* <math>V</math> - множество вершин.
* <math>G = (V,E) </math> - неориентированный граф, заданный множеством вершин <math>V</math> и множеством рёбер <math>E</math>
* <math>MST(G)</math> (Minimum Spanning Tree) - минимальное остовное дерево графа <math></math>. Остовное дерево — ациклический связный подграф данного связного неориентированного графа, в который входят все его вершины. Минимальное остовное дерево в связанном взвешенном неориентированном графе — это остовное дерево этого графа, имеющее минимальный возможный вес, где под весом дерева понимается сумма весов входящих в него рёбер.
* <math>MSF(G)</math> (Minimum Spanning Forest) - набор минимальных остовных деревьев для всех компонент связности графа <math> G </math>

В описании алгоритмов этой статьи часто используется термин "построение MST", подразумевая, что на самом деле в результате построения может получиться как одна компонента связности (MST), так и множество компонент связности (MSF).

==== Алгоритмы кластеризации ====
'''SEMST'''(standard Euclidean minimum spanning tree) - простейший алгоритм, основанный на заранее известном числе кластеров <math> k </math>. Путём удаления <math> k - 1 </math> связей с наибольшим весом предполагается разбиение остовного дерева на нужное количество кластеров. Иными словами минимальное остовное дерево разбивается на <math> k </math> поддеревьев: <math> G = \{G_1,G_2,...,G_k\} </math> путём минимизации суммы всех весов: <math> W = \sum ^k_{l=1} \sum _{x_i,x_j \in V_l} w_{x_i,x_j} -> min </math>, где <math> V_l </math> - множество вершин в поддереве <math> G_l </math>. В конце такой процедуры каждое множество <math> V_l </math> становится кластером <math> C_l </math>. Поскольку (в случае использования алгоритма Крускала для построения остовного дерева) рёбра перед началом кластеризации уже отсортированы, для удаления наибольших <math> k </math> рёбер требуется <math> O(k) </math> операций, и для распределения получившихся вершин по кластерам требуется время <math> O(n) </math>.'''

'''CEMST'''(maximum cost Euclidean minimum spanning tree) - Работает в точности, как и SEMST, но здесь вместо весов рёбер используется т.н. "стоимость", которая высчитывается следующим образом: если ребро <math> (x_i, x_j) </math> соединяет вершины <math> x_i </math> и <math> x_j </math>, то его "стоимость" считается как: <math> Cost_{x_i, x_j} = w_{x_i,x_j} * Deg(x_i) * Deg(x_j) </math>, где <math> Deg(x_i) </math> - степень вершины <math> x_i </math> (т.е. количество рёбер графа G, инцидентных вершине <math> x_i </math>). В остальном алгоритм действует точно так же, как и SEMST, удаляя <math> k-1 </math> рёбер с наибольшей "стоимостью". Сложность <math> O(k) </math> . Алгоритм направлен на удаление рёбер, соединяющих высоко нагруженные (с точки зрения количества инцидентных рёбер) вершины.

'''ZEMST''' (The Zahn’s maximum spanning tree (Zahn, 1971)) <ref> Attribute Clustering Based on Heuristic Tree Partition Jorge Cordero H. and Yifeng Zeng Department of Computer Science Aalborg University 9220 Aalborg, Denmark</ref> - отличается от двух предыдущих алгоритмов в первую очередь тем, что здесь количество кластеров заранее не известно, но определяется исходя из данных. Данный алгоритм не является жадным, в отличие от первых двух, так как в нём рассматривается не только само ребро и его вес, а также и поддеревья, которые соединены этим ребром. То есть для ребра <math> (x_i, x_j) </math> рассматриваются поддеревья <math> N_i = (V_{N_i}, E_{N_i}), N_j = (V_{N_j}, E_{N_j}) </math>, где <math> N_i </math> - поддерево глубины(высоты) <math> d </math>(величина d определяется эмпирически), состоящее из всех достижимых из вершины <math> x_j </math> вершин за <math> d </math> шагов через все достижимые из неё рёбра (исключая само ребро <math> (x_i, x_j) </math>).
Введём обозначения:
*<math>\overline{w_{N_i}} = \frac{\sum_{(x_r, x_s) \in E_{N_j}}w_{x_r,x_s}}{|E_{N_j}|} </math> - средний вес ребра в поддереве <math> N_i </math>
*<math>\sigma_{N_i} = \sqrt{\frac{\sum_{(x_r, x_s) \in E_{N_j}}(w_{x_r,x_s} - \overline{w_{N_i}})^2}{|E_{N_j}|}} </math> - стандартное отклонение веса ребра в поддереве <math> N_i </math>
Ребро <math> (x_i, x_j) </math> удаляется из списка в случае, если выполняется хотя бы одно из двух условий:
#<math> w_{x_i,x_j} > \overline{w_{N_i}} - \sigma_{N_i} </math>
#<math> w_{x_i,x_j} > \overline{w_{N_j}} - \sigma_{N_j} </math>
#<math> w_{x_i,x_j} > \frac{\sum_{(x_r, x_s) \in E_i \cup E_j}w_{x_r,x_s}}{|E_i \cup E_j|} </math>

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

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

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

# Приведение задачи наборе векторов данных к задаче о поиске минимального остовного дерева в графе (то есть нахождение расстояний между всеми парами данных векторов с использованием выбранной метрики, и запись этого расстояния как веса ребра, соединяющего эти вершины). Последовательная сложность: <math> O(n^2) </math>
# Поиск минимального остовного дерева. Последовательная сложность: <math> O(E*log(E)) </math>
# Разбиение остовного дерева на кластеры. Последовательная сложность зависит от реализации. (от <math> O(1) </math> в случае SEMST до <math> O(n^2) </math> в случае ZEMST).

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

В реализации алгоритма используются следующие структуры данных:
#'''Узел'''(Node)(Вершина) - Представляется набором координат в выбранном пространстве.
#'''Ребро'''(Edge) - Представляется: двумя индексами вершин, которые соединяет; своим весом; флагом, который указывает, входит ли данное ребро в минимальное остовное дерево.

В дальнейшем описании алгоритма используются следующие макрооперации:
#Вычисление расстояния между вершинами.
#Добавление ребра в граф - Осуществляется путём выставление специального флага у соответствующего ребра в true;
#Удаление ребра из графа - Операция, обратная к добавление: соответствующий флаг устанавливается в false. В начальный момент времени у всех рёбер флаг установлен в false, что означает отсутствие рёбер в графе.

Следующие три используемые операции относятся к реализации алгоритма Крускала при помощи леса непересекающихся множеств. Подробнее об этой структуре и связанных операциях можно почитать, например, здесь <ref> Томас Кормен и др. Алгоритмы: построение и анализ = INTRODUCTION TO ALGORITHMS. — 2-е изд. — М.: «Вильямс», 2006. — С. 1296. — ISBN 0-07-013151-1. (Глава 21. Раздел 21.3: "Леса непересекающихся множеств) </ref>, в данном пункте они будут только перечислены:
#Создание дерева с одним узлом - Make-Set
#Объединение компонент связности - Union
#Поиск компонент связности - Find-Set

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

<source lang="cpp">
int N; // Размер входных данных
int number_of_clusters; // Число кластеров
int size = N* (N-1) / 2; // Количество связей в полном графе
Node nodes[N]; // Вершины(точки), заданные начальными условиями
Edge edges[size]; // Все расстояния между вершинами
vector<Edge> MST; // Рёбра минимального остовного дерева
read_data(&nodes, file_name); // Считывание начальных данных

//----------------Часть 1--------------//
for(int i = 0; i < N-1; i++) {
for(int j = i+1; j < N; j++) {
double distance = getDistance(node[i], node[j]); // Вычисление расстояния между вершинами
edges[i*N + j] = Edge(i,j,distance); // Запись значения расстояния в массив
}
}

//----------------Часть 2--------------//
sort(edges, size); // Сортировка рёбер графа в порядке возрастания
for(int i = 0; i < size; i++) { // Обходим список рёбер по возрастанию
if(find_set(edges[i].first) != find_set(edges[i].second)) { // Если вершины принадлежат разным подграфам - связываем их
Union(edges[i].first, edges[i].second); // Если вершины принадлежат разным подграфам - связываем их
MST.push_back(edges[i]); // Запись использованного ребра в минимальное остовное дерево
edges[i]->is_in_MST = true; // Запись использованного ребра в минимальное остовное дерево
}
}

//----------------Часть 3--------------//
for(int i = MST.size() - 1; i > MST.size() - 1 - number_of_clusters; i--) {
remove_edge(MST, i); // Удаление самых длинных рёбер из MST - формирование кластеров
}
write_data(MST); // Запись выходных данных
</source>

Как описано в пункте 1.3, весь описываемый алгоритм (начиная от момента получения данных и заканчивая моментом, когда данные отданы на вывод), может быть условно разделён на три части. В то время как первая часть может быть достаточно эффективно решена "в лоб", вторая и третьи части, как указано в пункте 1.1, могут иметь альтернативы. В данном фрагменте кода подробно описано использование [[Алгоритм Крускала | Алгоритма Крускала]] для построения MST, и алгоритма SEMST для разбиения на кластеры.

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

Как и в остальных пунктах, здесь сложность алгоритма состоит их суммы сложностей трёх его составных частей. Если оценивать сложность асимптотически в зависимости от входных данных, то:

<math> T(n) = O(n^2) + O(\frac{n (n-1)}{2})log(\frac{n (n-1)}{2})) + O(1) </math>

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

<math> O(\frac{n (n-1)}{2} log(\frac{n (n-1)}{2}) = O(n^2 log(n^2)) = O(2 n^2 log(n)) = O(n^2 log(n)) </math>

Отсюда видно, что для входных данных этого алгоритма асимптотические сложности алгоритмов Крускала, Прима и Борувки совпадают.

Таким образом, последовательная сложность алгоритма: <math> O(n^2 log(n)) </math>

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

[[File:Graph_algo10.png|frame|center|alt=Алгоритм| Макро-описание параллельного алгоритма кластеризации]]

=== Ресурс параллелизма алгоритма ===
Данная задача хорошо распараллеливается благодаря тому, что все "тяжелые" вычислительные задачи, начиная с момента считывания входных данных, можно распределить по процессам практически равномерно. Это достигается за счет следующей реализации:
#Мастер-процесс считывает входные данные и отправляет их остальным процессам с помощью MPI_Broadcast.
#Все пары точек разбиваются так, что каждому процессу достается одинаковое количество пар.
#Каждый процесс-рабочий строит MST на своём наборе пар точек.
#Процессы объединяют свои деревья по алгоритму, изображенному в информационном графе. То есть объединение осуществляется последовательно между группами размера <math>2^k</math>, где <math> k \in 1,2,..log_2p</math>, где p - число процессов.

Таким образом '''высота Ярусно-Параллельной формы''' (при наличии <math> p = 2^i </math> процессоров) будет <math> 1 + i + 1 + 1 </math>.
В то же время, как будет показано в пункте 1.10, оптимальное количетво процессоров может быть оценено по формуле <math> p(N) \approx \sqrt {\frac{N-1}{2}} </math>. Тогда '''ширину Ярусно-Параллельной формы''' можно оценить как <math> O(\sqrt{N}) </math>. Учитывая приближенную формулу для числа процессоров, оценим высоту ЯП при помощи соотношения <math> 2^i \approx \sqrt {\frac{N-1}{2}} </math>. Тогда высоту ЯП можно оценить как <math> O(log(N)) </math>.

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

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

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

==== Входные данные ====
В качестве входных данных программе дается множество векторов <math> [x_1,x_2,...,x_N]</math>, где <math> x_j = (a_{1j}, a_{2j}, ..., a_{nj})</math> размерности <math>n</math>. Для удобства изучения свойств алгоритма и отображения результатов можно брать массив векторов размерности 2. В этом случае наглядность будет обеспечена естественной возможностью отобразить вектора в плоскости.

Кроме того может оказаться полезным особым образом подготовить данные перед анализом (удаление "шумов", выбросов и масштабирование данных по тем или иным координатам).
==== Выходные данные ====
Выходными данными программы будет множество <math> M = ((x_1,x_2,..,x_k),(x_{k+1},...),...) </math>, состоящее из сгруппированных по кластерам векторов из входных данных.

В конкретной программе это может быть реализовано путём записи <math> N </math> строк вида <math>(x_{i}, Cluster-Number)</math> в выходной файл.

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

Одним из трудных мест параллельной реализации является правильный выбор количества процессов. Для удобства анализа рассматривается число процессоров <math> p = 2^i </math>, где <math> i \in \mathbb {N} </math>. Ясно, что такое допущение не повлияет на качество анализа, так как другое число процессоров лишь приведет к незначительным накладным расходам, сложность которых асимптотически стремится к нулю. В таком случае можно также ввести допущение о размере входных данных: <math> N = 2^j </math>, где <math> j \in \mathbb {N}, j > i </math>. В этом случае MST-часть дерева графа алгоритма является идеально сбалансированным бинарным деревом. Тогда сложность можно оценить следующим образом:
#На первом этапе каждый процесс производит расчет на <math> 2^{j - i} * (2^j - 1)</math> рёбрах, получая локальное MST(или MSF) на не более чем <math> N </math> вершинах.
#Далее следует <math> i = log_2(2^i) </math> шагов объединения не более чем по N рёбер в каждом.

Таким образом, задача эффективного запуска алгоритма состоит в том, чтобы найти оптимальный баланс между количеством расчетов на каждом узле на первом шаге и общим количеством объединений поддеревьев. Пусть дано <math> p = 2^i </math> вычислительных узлов и <math> N = 2^j </math>. В таком случае каждый узел получает считает <math> 2^{j - i} * (2^j - 1)</math> рёбер на первом шаге. Высота части ЯП-формы, отвечающей за MST, равна <math> i </math>. Тогда всего будет <math> i </math> уровней объединений MST с числом рёбер не более чем <math> 2N </math> для каждого вычислительного узла.

==== Оценка скорости работы параллельного алгоритма ====

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

*<math> T'(N,p) = \frac{N(N - 1)}{2 p} * logN + 2N*log(N) * log_2p</math>.

Объяснение формулы: первое слагаемое, исходя из оценки для сложности алгоритма Прима: <math> O(ElogV) </math>, - время(число операций) расчета на каждом процессоре на первом шаге. После первого шага (поскольку построено минимальное остовное дерево) каждый процесс передает не более чем <math> N </math> рёбер дальше. Второе слагаемое: каждый процесс после первого шага получает не более чем <math> 2N </math> рёбер (от двух процессоров при объединении), и всего таких шагов объединения не более чем <math> log_2p </math>, при этом предполагается, что сложностью объединения <math> 2N </math> рёбер на каждом шаге можно пренебречь (или допустить его пренебрежительно малым), поскольку предполагается, что все процессы после первого шага получают свою часть уже отсортированных рёбер(то есть наибольшее ребро процессора <math> i </math> меньше наименьшего ребра процессора <math> i+1 </math>), и объединение будет просто конкатенацией блоков памяти.

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

1. <math> N = 10^4</math>
[[File:График1_.JPG|frame|center|alt=Алгоритм| По оси абсцисс: количество вычислительных узлов. По оси ординат: время вычислений. При фиксированном <math> N </math>]]

2. <math> N = 1.5*10^4 </math>
[[File:График2_.JPG|frame|center|alt=Алгоритм| По оси абсцисс: количество вычислительных узлов. По оси ординат: время вычислений. При фиксированном <math> N </math>]]

Из этих графиков становится видно качественное поведение времени вычислений при увеличении числа процессоров. Можно заметить, что для каждого набора входных данных есть число процессоров, минимизирующее время вычислений. Но в то же время видно, что при слишком большом количестве процессоров алгоритм начинает работать хуже, чем при меньшем. Это вполне понятно: Слишком большое число процессоров порождает большое число обменов между ними, объединений деревьев, сортировок, и т.д. Таким образом, именно эта часть <math> 2N*log(N) * log_2p </math> оценки времени вычислений отвечает за ухудшение эффективности алгоритма при числе процессоров, которое больше оптимального. Кроме того, видно, что при увеличении объёма входных данных оптимальное количество процессоров также увеличивается: количество обменов и слияний деревьев компенсируется уменьшением вычислительной нагрузки на каждый отдельный процессор.

Благодаря такой оценке становится возможным оценить примерное оптимальное число процессоров <math> p </math> в зависимости от объёма входных данных <math> N </math>. Продифференцировав приближенную формулу <math> T'(N,p) = \frac{N(N - 1)}{2 p} * logN + 2N*log(N) * log_2p </math> по <math> p </math> и приравняв производную нулю, получим следующее выражение для оптимального числа процессоров:

<math> p(N) \approx \frac{N-1}{4} </math>

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

Согласно определению, [[глоссарий#Вычислительная мощность|''вычислительная мощность'']] алгоритма равна отношению числа операций к суммарному объему входных и выходных данных. В то же время, учитывая вышесказанное, видно, что число операций в данном алгоритме зависит не только от объема входных данных, но также от числа процессоров. Таким образом, имеет смысл оценить вычислительную мощность как в случае оптимального числа процессоров, так и в общем случае числа процессоров, равного <math> p </math>.

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

<math> \frac{N(N - 1)}{2} * logN + \sum_{i = 0}^{log_2p}(2N*log(N) * \frac{p}{2^i}) = N logN (\frac{N-1}{2} + 2 * p * \sum_{i = 0}^{log_2p}( \frac{1}{2^i})) = </math> {переходя к пределу в сумме} <math> \approx N logN (\frac{N-1}{2} + 2 * p) </math>

Таким образом, вычислительная мощность в общем случае: <math> \approx \frac{N logN (\frac{N-1}{2} + 2 * p)}{2N} = \frac{logN *(\frac{N-1}{2} + 2 * p)}{2} </math>

В случае оптимального числа вычислительных узлов: <math> \approx \frac{N logN (\frac{N-1}{2} + \frac{N-1}{2})}{2N} = \frac{logN * (N-1)}{2}</math>

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

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

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

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

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

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

[[File:Efficiency2.JPG|frame|center|alt=Алгоритм| Производительность алгоритма]]

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

[[File:Timeline1.JPG|frame|center|alt=Алгоритм| Вычислительное время алгоритма для <math>N = 17000</math>]]
[[File:Снимок2.JPG|frame|center|alt=Алгоритм| Вычислительное время алгоритма для <math>N = 3000</math>]]

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

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

=== Существующие реализации алгоритма ===
Как таковые, алгоритмы самого процесса кластеризации в популярных библиотеках (таких, как Scipy, Numpy или Boost) не реализованы (в отличие от других алгоритмов кластеризации). Однако, можно найти пользовательские любительские реализации (некоторые из которых приведены в списке ниже). Кроме того, существует масса реализаций основного коспонента данного алгоритма - вычисления MST - на многих языках программирования в разных библиотеках. Ссылки на некоторые из этих реализаций(перечислить все было бы невозможно) также приведены в списке ниже.

*[https://github.com/jakevdp/mst_clustering Minimum Spanning Tree Clustering in Python Author: Jake VanderPlas]
*[https://github.com/amueller/information-theoretic-mst Information Theoretic Clustering using Minimum Spanning Trees]
*[http://www.boost.org/doc/libs/1_51_0/libs/graph/doc/prim_minimum_spanning_tree.html C++ Boost library prim_minimum_spanning_tree]
*[http://www.boost.org/doc/libs/1_35_0/libs/graph/doc/kruskal_min_spanning_tree.html C++ Boost library kruskal_minimum_spanning_tree]
*[http://jgrapht.org/javadoc/org/jgrapht/alg/PrimMinimumSpanningTree.html Java library JGraphT PrimMinimumSpanningTree]
*[http://jgrapht.org/javadoc/org/jgrapht/alg/KruskalMinimumSpanningTree.html Java library JGraphT KruskalMinimumSpanningTree]
*[http://docs.scipy.org/doc/scipy-0.15.1/reference/generated/scipy.sparse.csgraph.minimum_spanning_tree.html SciPy library MST]

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

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

2016-11-16T07:23:48Z

Zhum:

п. 2.4

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

[[Участник:Zhum|Zhum]] ([[Обсуждение участника:Zhum|обсуждение]]) 10:23, 16 ноября 2016 (MSK)

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

2016-11-16T07:16:22Z

Zhum:

п. 2.4

* нет описания аппаратной платформы
* нет указания на реализацию алгоритма (своя или сторонняя)
[[Участник:Zhum|Zhum]] ([[Обсуждение участника:Zhum|обсуждение]]) 10:16, 16 ноября 2016 (MSK)