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

Участник:Илья Егоров/Алгоритм k-средних

2016-12-13T19:15:28Z

Илья Егоров:

{{Assignment|Zhum}}
{{Assignment|Zhum|Konshin}}

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

Страница создана группой "[[U:Илья Егоров|Илья Егоров]] — [[U:Богомазов Евгений|Евгений Богомазов]]".

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

= ЧАСТЬ. Свойства и структура алгоритмов =
== Общее описание алгоритма ==

Алгоритм кластеризации k-средних впервые был предложен в 1950-х годах математиками Гуго Штейнгаузом и Стюартом Ллойдом независимо друг от друга. Наибольшую популярность он получил после работы Маккуина.

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

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

== Математическое описание алгоритма ==
'''Исходные данные:'''
* Совокупность <math>n</math> <math>d</math>-мерных векторов <math> X = \{x_1 \dots x_n\} , </math> где <math> x_i = \{x_{i1} \dots x_{id}\} </math>
* Предполагаемое количество кластеров <math>k</math>

'''Выходные данные:'''
* Разбиение 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}{\rm argmin } \sum_{x \in S_i} ||x-y||^2_E \\ \Mu = \underset{\tilde{\Mu}}{\rm argmin } \sum_{i \in k} \sum_{x \in S_i} ||x-\tilde{\mu_i}||^2_E \end{cases} </math>

'''Алгоритм:'''

1) <math> \mu_{i} = {\rm random} </math>

2) <math> S_i = \{x \in S~|~\underset{j}{\rm 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>. Для <math>d</math>-мерного вектора <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\times k\times d</math> операций умножений и <math>n\times k\times (d-1)</math> операций сложений.

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

В алгоритме можно выделить следующие макрооперации:
*Вычисление расстояния между векторами,
*Суммирование векторов,
*Поиск минимума в векторе,
*Сравнение векторов,
*Деление вектора на скаляр.

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

'''2a)''' При составлении матрицы расстояний <math>k \times n </math> раз производится макрооперация "Вычисление расстояния между векторами".

'''2b)''' При нахождение вектора распределения объектов по кластерам <math>n</math> раз производится макрооперация "Поиск минимума в векторе".

'''3)''' При пересчете центроидов <math>n - k</math> раз производится макрооперация "Суммирование векторов" и <math>k</math> раз — "Деление вектора на скаляр".

'''4)''' Для проверки критерия останова требуется <math>k</math> раз произвести макрооперацию "Сравнение векторов" для сопоставления обновленных значений центроидов с уже имеющимися.

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

Последовательность шагов алгоритма следующая:

'''1) Инициализация центроидов <math>\Mu</math>, <math> {\rm iter} = 1 </math>, задание максимального количество итераций <math>{\rm maxiter}</math>'''

'''2a) Нахождение матрицы расстояний '''<math>{\rm dist}:</math>

<math>{\rm dist}_{ij} = \sum_{l = 1\dots d} (x_{il}-\mu_{jl})^2</math>

'''2b) Нахождение вектора распределения объектов по кластерам '''<math>{\rm index}: </math>

<math>{\rm index}_{i} = \underset{j}{\rm argmin }~{\rm 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, {\rm index}_l = i\} </math>

'''4) Проверка критерия останова:'''

'''Если''' <math> \exists i: \tilde{\mu_i} \neq \mu_i</math>, <math> {\rm iter} < {\rm maxiter} </math>,

'''то''' <math> {\rm inc}({\rm iter}), \Mu=\tilde{\Mu},</math> '''GOTO 2.а.'''

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

'''1)''' Сложность инициализации в общем случае зависит от применяемого метода генерации/получения случайных чисел, но ей можно пренебречь

'''2a)''' Вычисление матрицы расстояний требует <math> n\times k\times d </math> операций умножения и <math> n\times k\times (d-1) </math> операций сложения

'''2b)''' Нахождение вектора распределения требует <math> n\times (k-1) </math> операций сравнения

'''3)''' Для вычисления <math> \tilde{\Mu} </math> требуется <math> (n - k + 1) \times d </math> операций сложения и <math> k \times d </math> операций деления

'''4)''' Для критерия останова требуется <math> n\times d </math> сравнений

Итого: так как максимальное количество итераций задается в алгоритме заранее и не зависит от входных данных, то количество итераций ограничено константой. Тогда сложность алгоритма:

* <math> O(n\times k\times d)</math> операций сложения/вычитания
* <math> O(n\times k\times d)</math> операций умножения, <math> O(k\times d) </math> операций деления

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

Рассмотрим вычислительные этапы алгоритма k-means. Это распределение объектов по кластерам и перерасчет центроидов.

Распределение объектов по кластерам состоит из нахождения матрицы расстояний между <math>X</math> и <math>\Mu</math> (этапа '''2a)''') и нахождения индекса минимального элемента в каждой строке (этап '''2b)'''). Ниже приведен информационный граф данного этапа.

[[Файл:EgorovBogomazovInf.png |800px|thumb|center|Рисунок 1. Нахождение вектора индексов распределения по кластерам]]

Рассмотрим этап вычисления ячейки <math> {\rm dist}_{ij} </math> матрицы более подробно. Он представляет из себя скалярное произведение d-мерных векторов <math> x_i </math> и <math> \mu_j </math>. Ниже приведена граф для данной операции.

[[Файл:EgorovBogomazovDist.png|600px|thumb|center|Рисунок 2. Операция вычисления расстояния]]

На этапе '''3)''' происходит суммирование всех <math> x_l </math> с одинаковым значением индекса в промежуточные суммы. Одновременно происходит подсчет количество элементов с фиксированным индексом. Затем происходит деление промежуточных сумм на соответствующее количество элементов в новом кластере, благодаря чему удается получить обновленные центроиды <math> \tilde{\mu}</math>

[[Файл:EgorovBogomazovNewCluster.png|800px|thumb|center|Рисунок 3. Обновление центроидов]]

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

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

'''2a)''' Нахождение каждой ячейки матрицы <math> {\rm dist} </math> может происходить полностью независимо, так как они находятся на одном ярусе. При рассмотрении операции вычисления значения конкретной ячейки <math> {\rm dist}_{ij} </math> можно заметить, что все операции умножения также независимы между собой, поэтому понадобится всего одно умножение. Конечный результат получается в результате суммирования всех слагаемых и достигается параллельно за <math> \log(d) </math> бинарных операций сложения при помощи стандартного метода ''reduction''.

'''2b)''' Нахождение вектора распределений заключается в нахождении минимального элемента в каждой строке матрицы <math> {\rm 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>{\rm index}</math>, который можно выполнить за <math> n </math> операций косвенных адресаций.

'''4)''' Все сравнения для критерия останова также независимы между собой и могут быть выполнены за одну операцию сравнения, а финальный результат может быть получен за одну операцию сложения при работе над общей памятью (к примеру, прибавление единицы при несовпадении в общую память и сравнение ее с 0 по завершению) или за <math>\log(k\times d)</math> сложений иначе.

Так как количество итераций ограничено константой, то на сложность оно не влияет. В итоге, параллельная сложность алгоритма k-means такова:
* <math> O(\log(n\times d)) </math> операций сложения
* <math> O(\log(k)) </math> операций сравнения
* <math> O(1) </math> операций умножения и деления

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

'''Входные данные''': Количество кластеров <math>k</math>, <math>n</math> кластеризуемых элементов

Дополнительные ограничения:
* <math>k</math> — положительное число, т. е. <math>k > 0</math>.
* Для кластеризуемых элементов определена метрика (расстояние между объектами)

'''Объём входных данных''': <math>n \times d + 1</math> (кластеризуемые объекты в виде векторов и число <math>k</math>)

'''Выходные данные''': Массив, в который записаны принадлежности каждого элемента кластеру (допустим вывод в другой эквивалентной более удобной структуре).

'''Объём выходных данных''': Размер массива равен <math>2 \times n</math>.

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

'''Вычислительная мощность'''

Число действий: <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.

Код собирался под gcc c опцией -fopenmp. В очереди задача не стояла, так как код считался на одном процессоре, hyperthreading не использовался.

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

* число процессоров [1 : 16] с увеличением в 2 раза;
* размер данных [100000 : 1600000] с увеличением в 2 раза.

В результате проведённых экспериментов были получены следующие данные:

* Максимальная эффективность в точке достигается при переходе от 1 потока на 4 при минимальном размере данных, она равна <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|Рисунок 4. Параллельная реализация алгоритма k-средних. Изменение вычислительного времени алгоритма в зависимости от числа процессоров и размера исходных данных.]]

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

[[file:Egorov_Bogomazov_Efficiency.jpg|thumb|center|700px|Рисунок 5. Параллельная реализация алгоритма 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]]

Участник:Илья Егоров/Алгоритм k-средних

2016-12-13T17:10:34Z

Илья Егоров:

{{Assignment|Zhum}}

{{algorithm
| name = Алгоритм k-средних (k-means)
| serial_complexity = <math>O(n\times k\times d)</math>
| input_data = <math>n\times 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}{\rm argmin } \sum_{x \in S_i} ||x-y||^2_E \\ \Mu = \underset{\tilde{\Mu}}{\rm 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}{\rm 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\times k\times d</math> операций умножений и <math>n\times k\times (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> {\rm iter} = 1 </math>, задание максимального количество итераций <math>{\rm maxiter}</math>'''

'''2a) Нахождение матрицы расстояний '''<math>{\rm dist}:</math>

<math>{\rm dist}_{ij} = \sum_{l = 1\dots d} (x_{il}-\mu_{jl})^2</math>

'''2b) Нахождение вектора распределения объектов по кластерам '''<math>{\rm index}: </math>

<math>{\rm index}_{i} = \underset{j}{\rm argmin }~{\rm 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, {\rm index}_l = i\} </math>

'''4) Проверка критерия останова:'''

'''Если''' <math> \exists i: \tilde{\mu_i} \neq \mu_i</math>, <math> {\rm iter} < {\rm maxiter} </math>,

'''то''' <math> {\rm inc}({\rm iter}), \Mu=\tilde{\Mu},</math> '''GOTO 2.а.'''

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

'''1)''' Сложность инициализации в общем случае зависит от применяемого метода генерации/получения случайных чисел, но ей можно пренебречь

'''2a)''' Вычисление матрицы расстояний требует <math> n\times k\times d </math> операций умножения и <math> n\times k\times (d-1) </math> операций сложения

'''2b)''' Нахождение вектора распределения требует <math> n\times (k-1) </math> операций сравнения

'''3)''' Для вычисления <math> \tilde{\Mu} </math> требуется <math> (n - k + 1) \times d </math> операций сложения и <math> k \times d </math> операций деления

'''4)''' Для критерия останова требуется <math> n\times d </math> сравнений

Итого: так как максимальное количество итераций задается в алгоритме заранее и не зависит от входных данных, то количество итераций ограничено константой. Тогда сложность алгоритма:

* <math> O(n\times k\times d)</math> операций сложения/вычитания
* <math> O(n\times k\times d)</math> операций умножения, <math> O(k\times d) </math> операций деления

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

Рассмотрим вычислительные этапы алгоритма k-means. Это распределение объектов по кластерам и перерасчет центроидов.

Распределение объектов по кластерам состоит из нахождения матрицы расстояний между <math>X</math> и <math>\Mu</math> (этапа '''2a)''') и нахождения индекса минимального элемента в каждой строке (этап '''2b)'''). Ниже приведен информационный граф данного этапа.

[[Файл:EgorovBogomazovInf.png |800px|thumb|center|Рисунок 1. Нахождение вектора индексов распределения по кластерам]]

Рассмотрим этап вычисления ячейки <math> {\rm dist}_{ij} </math> матрицы более подробно. Он представляет из себя скалярное произведение d-мерных векторов <math> x_i </math> и <math> \mu_j </math>. Ниже приведена граф для данной операции.

[[Файл:EgorovBogomazovDist.png|600px|thumb|center|Рисунок 2. Операция вычисления расстояния]]

На этапе '''3)''' происходит суммирование всех <math> x_l </math> с одинаковым значением индекса в промежуточные суммы. Одновременно происходит подсчет количество элементов с фиксированным индексом. Затем происходит деление промежуточных сумм на соответствующее количество элементов в новом кластере, благодаря чему удается получить обновленные центроиды <math> \tilde{\mu}</math>

[[Файл:EgorovBogomazovNewCluster.png|800px|thumb|center|Рисунок 3. Обновление центроидов]]

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

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

'''2a)''' Нахождение каждой ячейки матрицы <math> {\rm dist} </math> может происходить полностью независимо, так как они находятся на одном ярусе. При рассмотрении операции вычисления значения конкретной ячейки <math> {\rm dist}_{ij} </math> можно заметить, что все операции умножения также независимы между собой, поэтому понадобится всего одно умножение. Конечный результат получается в результате суммирования всех слагаемых и достигается параллельно за <math> \log(d) </math> бинарных операций сложения при помощи стандартного метода ''reduction''.

'''2b)''' Нахождение вектора распределений заключается в нахождении минимального элемента в каждой строке матрицы <math> {\rm 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>{\rm index}</math>, который можно выполнить за <math> n </math> операций косвенных адресаций.

'''4)''' Все сравнения для критерия останова также независимы между собой и могут быть выполнены за одну операцию сравнения, а финальный результат может быть получен за одну операцию сложения при работе над общей памятью (к примеру, прибавление единицы при несовпадении в общую память и сравнение ее с 0 по завершению) или за <math>\log(k\times d)</math> сложений иначе.

Так как количество итераций ограничено константой, то на сложность оно не влияет. В итоге, параллельная сложность алгоритма k-means такова:
* <math> O(\log(n\times 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.

Код собирался под gcc c опцией -fopenmp. В очереди задача не стояла, так как код считался на одном процессоре, hyperthreading не использовался.

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

* число процессоров [1 : 16] с увеличением в 2 раза;
* размер данных [100000 : 1600000] с увеличением в 2 раза.

В результате проведённых экспериментов были получены следующие данные:

* Максимальная эффективность в точке достигается при переходе от 1 потока на 4 при минимальном размере данных, она равна <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|Рисунок 4. Параллельная реализация алгоритма k-средних. Изменение вычислительного времени алгоритма в зависимости от числа процессоров и размера исходных данных.]]

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

[[file:Egorov_Bogomazov_Efficiency.jpg|thumb|center|700px|Рисунок 5. Параллельная реализация алгоритма 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]]

Участник:Илья Егоров/Алгоритм k-средних

2016-12-13T17:09:54Z

Илья Егоров:

{{Assignment|Zhum}}

{{algorithm
| name = Алгоритм k-средних (k-means)
| serial_complexity = <math>O(n\times k\times d)</math>
| input_data = <math>n\times 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}{\rm argmin } \sum_{x \in S_i} ||x-y||^2_E \\ \Mu = \underset{\tilde{\Mu}}{\rm 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}{\rm 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\times k\times d</math> операций умножений и <math>n\times k\times (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> {\rm iter} = 1 </math>, задание максимального количество итераций <math>{\rm maxiter}</math>'''

'''2a) Нахождение матрицы расстояний '''<math>{\rm dist}:</math>

<math>{\rm dist}_{ij} = \sum_{l = 1\dots d} (x_{il}-\mu_{jl})^2</math>

'''2b) Нахождение вектора распределения объектов по кластерам '''<math>{\rm index}: </math>

<math>{\rm index}_{i} = \underset{j}{\rm argmin }~{\rm 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, {\rm index}_l = i\} </math>

'''4) Проверка критерия останова:'''

'''Если''' <math> \exists i: \tilde{\mu_i} \neq \mu_i</math>, <math> {\rm iter} < {\rm maxiter} </math>,

'''то''' <math> {\rm inc}({\rm iter}), \Mu=\tilde{\Mu},</math> '''GOTO 2.а.'''

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

'''1)''' Сложность инициализации в общем случае зависит от применяемого метода генерации/получения случайных чисел, но ей можно пренебречь

'''2a)''' Вычисление матрицы расстояний требует <math> n\times k\times d </math> операций умножения и <math> n\times k\times (d-1) </math> операций сложения

'''2b)''' Нахождение вектора распределения требует <math> n\times (k-1) </math> операций сравнения

'''3)''' Для вычисления <math> \tilde{\Mu} </math> требуется <math> (n - k + 1) \times d </math> операций сложения и <math> k \times d </math> операций деления

'''4)''' Для критерия останова требуется <math> n\times d </math> сравнений

Итого: так как максимальное количество итераций задается в алгоритме заранее и не зависит от входных данных, то количество итераций ограничено константой. Тогда сложность алгоритма:

* <math> O(n\times k\times d)</math> операций сложения/вычитания
* <math> O(n\times k\times d)</math> операций умножения, <math> O(k\times d) </math> операций деления

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

Рассмотрим вычислительные этапы алгоритма k-means. Это распределение объектов по кластерам и перерасчет центроидов.

Распределение объектов по кластерам состоит из нахождения матрицы расстояний между <math>X</math> и <math>\Mu</math> (этапа '''2a)''') и нахождения индекса минимального элемента в каждой строке (этап '''2b)'''). Ниже приведен информационный граф данного этапа.

[[Файл:EgorovBogomazovInf.png |800px|thumb|center|Рисунок 1. Нахождение вектора индексов распределения по кластерам]]

Рассмотрим этап вычисления ячейки <math> {\rm dist}_{ij} </math> матрицы более подробно. Он представляет из себя скалярное произведение d-мерных векторов <math> x_i </math> и <math> \mu_j </math>. Ниже приведена граф для данной операции.

[[Файл:EgorovBogomazovDist.png|600px|thumb|center|Рисунок 2. Операция вычисления расстояния]]

На этапе '''3)''' происходит суммирование всех <math> x_l </math> с одинаковым значением индекса в промежуточные суммы. Одновременно происходит подсчет количество элементов с фиксированным индексом. Затем происходит деление промежуточных сумм на соответствующее количество элементов в новом кластере, благодаря чему удается получить обновленные центроиды <math> \tilde{\mu}</math>

[[Файл:EgorovBogomazovNewCluster.png|800px|thumb|center|Рисунок 3. Обновление центроидов]]

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

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

'''2a)''' Нахождение каждой ячейки матрицы <math> {\rm dist} </math> может происходить полностью независимо, так как они находятся на одном ярусе. При рассмотрении операции вычисления значения конкретной ячейки <math> {\rm dist}_{ij} </math> можно заметить, что все операции умножения также независимы между собой, поэтому понадобится всего одно умножение. Конечный результат получается в результате суммирования всех слагаемых и достигается параллельно за <math> \log(d) </math> бинарных операций сложения при помощи стандартного метода ''reduction''.

'''2b)''' Нахождение вектора распределений заключается в нахождении минимального элемента в каждой строке матрицы <math> {\rm 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>{\rm index}</math>, который можно выполнить за <math> n </math> операций косвенных адресаций.

'''4)''' Все сравнения для критерия останова также независимы между собой и могут быть выполнены за одну операцию сравнения, а финальный результат может быть получен за одну операцию сложения при работе над общей памятью (к примеру, прибавление единицы при несовпадении в общую память и сравнение ее с 0 по завершению) или за <math>\log(k\times d)</math> сложений иначе.

Так как количество итераций ограничено константой, то на сложность оно не влияет. В итоге, параллельная сложность алгоритма k-means такова:
* <math> O(\log(n\times 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.

Код собирался под gcc c опцией -fopenmp. В очереди задача не стояла, так как код считался на одном процессоре, hyperthreading не использовался.

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

* число процессоров [1 : 16] с увеличением в 2 раза;
* размер данных [100000 : 1600000] с увеличением в 2 раза.

В результате проведённых экспериментов были получены следующие данные:

* Максимальная эффективность в точке достигается при переходе от 1 потока на 2 при минимальном размере данных, она равна <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|Рисунок 4. Параллельная реализация алгоритма k-средних. Изменение вычислительного времени алгоритма в зависимости от числа процессоров и размера исходных данных.]]

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

[[file:Egorov_Bogomazov_Efficiency.jpg|thumb|center|700px|Рисунок 5. Параллельная реализация алгоритма 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]]

Участник:Илья Егоров/Алгоритм k-средних

2016-12-13T17:08:09Z

Илья Егоров:

{{Assignment|Zhum}}

{{algorithm
| name = Алгоритм k-средних (k-means)
| serial_complexity = <math>O(n\times k\times d)</math>
| input_data = <math>n\times 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}{\rm argmin } \sum_{x \in S_i} ||x-y||^2_E \\ \Mu = \underset{\tilde{\Mu}}{\rm 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}{\rm 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\times k\times d</math> операций умножений и <math>n\times k\times (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> {\rm iter} = 1 </math>, задание максимального количество итераций <math>{\rm maxiter}</math>'''

'''2a) Нахождение матрицы расстояний '''<math>{\rm dist}:</math>

<math>{\rm dist}_{ij} = \sum_{l = 1\dots d} (x_{il}-\mu_{jl})^2</math>

'''2b) Нахождение вектора распределения объектов по кластерам '''<math>{\rm index}: </math>

<math>{\rm index}_{i} = \underset{j}{\rm argmin }~{\rm 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, {\rm index}_l = i\} </math>

'''4) Проверка критерия останова:'''

'''Если''' <math> \exists i: \tilde{\mu_i} \neq \mu_i</math>, <math> {\rm iter} < {\rm maxiter} </math>,

'''то''' <math> {\rm inc}({\rm iter}), \Mu=\tilde{\Mu},</math> '''GOTO 2.а.'''

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

'''1)''' Сложность инициализации в общем случае зависит от применяемого метода генерации/получения случайных чисел, но ей можно пренебречь

'''2a)''' Вычисление матрицы расстояний требует <math> n\times k\times d </math> операций умножения и <math> n\times k\times (d-1) </math> операций сложения

'''2b)''' Нахождение вектора распределения требует <math> n\times (k-1) </math> операций сравнения

'''3)''' Для вычисления <math> \tilde{\Mu} </math> требуется <math> (n - k + 1) \times d </math> операций сложения и <math> k \times d </math> операций деления

'''4)''' Для критерия останова требуется <math> n\times d </math> сравнений

Итого: так как максимальное количество итераций задается в алгоритме заранее и не зависит от входных данных, то количество итераций ограничено константой. Тогда сложность алгоритма:

* <math> O(n\times k\times d)</math> операций сложения/вычитания
* <math> O(n\times k\times d)</math> операций умножения, <math> O(k\times d) </math> операций деления

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

Рассмотрим вычислительные этапы алгоритма k-means. Это распределение объектов по кластерам и перерасчет центроидов.

Распределение объектов по кластерам состоит из нахождения матрицы расстояний между <math>X</math> и <math>\Mu</math> (этапа '''2a)''') и нахождения индекса минимального элемента в каждой строке (этап '''2b)'''). Ниже приведен информационный граф данного этапа.

[[Файл:EgorovBogomazovInf.png |800px|thumb|center|Рисунок 1. Нахождение вектора индексов распределения по кластерам]]

Рассмотрим этап вычисления ячейки <math> {\rm dist}_{ij} </math> матрицы более подробно. Он представляет из себя скалярное произведение d-мерных векторов <math> x_i </math> и <math> \mu_j </math>. Ниже приведена граф для данной операции.

[[Файл:EgorovBogomazovDist.png|600px|thumb|center|Рисунок 2. Операция вычисления расстояния]]

На этапе '''3)''' происходит суммирование всех <math> x_l </math> с одинаковым значением индекса в промежуточные суммы. Одновременно происходит подсчет количество элементов с фиксированным индексом. Затем происходит деление промежуточных сумм на соответствующее количество элементов в новом кластере, благодаря чему удается получить обновленные центроиды <math> \tilde{\mu}</math>

[[Файл:EgorovBogomazovNewCluster.png|800px|thumb|center|Рисунок 3. Обновление центроидов]]

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

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

'''2a)''' Нахождение каждой ячейки матрицы <math> {\rm dist} </math> может происходить полностью независимо, так как они находятся на одном ярусе. При рассмотрении операции вычисления значения конкретной ячейки <math> {\rm dist}_{ij} </math> можно заметить, что все операции умножения также независимы между собой, поэтому понадобится всего одно умножение. Конечный результат получается в результате суммирования всех слагаемых и достигается параллельно за <math> \log(d) </math> бинарных операций сложения при помощи стандартного метода ''reduction''.

'''2b)''' Нахождение вектора распределений заключается в нахождении минимального элемента в каждой строке матрицы <math> {\rm 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>{\rm index}</math>, который можно выполнить за <math> n </math> операций косвенных адресаций.

'''4)''' Все сравнения для критерия останова также независимы между собой и могут быть выполнены за одну операцию сравнения, а финальный результат может быть получен за одну операцию сложения при работе над общей памятью (к примеру, прибавление единицы при несовпадении в общую память и сравнение ее с 0 по завершению) или за <math>\log(k\times d)</math> сложений иначе.

Так как количество итераций ограничено константой, то на сложность оно не влияет. В итоге, параллельная сложность алгоритма k-means такова:
* <math> O(\log(n\times 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.

Код собирался под gcc c опцией -fopenmp. В очереди задача не стояла, так как код считался на одном процессоре, hyperthreading не использовался.

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

* число процессоров [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|Рисунок 4. Параллельная реализация алгоритма k-средних. Изменение вычислительного времени алгоритма в зависимости от числа процессоров и размера исходных данных.]]

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

[[file:Egorov_Bogomazov_Efficiency.jpg|thumb|center|700px|Рисунок 5. Параллельная реализация алгоритма 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]]

Участник:Илья Егоров/Алгоритм k-средних

2016-12-13T17:06:29Z

Илья Егоров:

{{Assignment|Zhum}}

{{algorithm
| name = Алгоритм k-средних (k-means)
| serial_complexity = <math>O(n\times k\times d)</math>
| input_data = <math>n\times 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}{\rm argmin } \sum_{x \in S_i} ||x-y||^2_E \\ \Mu = \underset{\tilde{\Mu}}{\rm 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}{\rm 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\times k\times d</math> операций умножений и <math>n\times k\times (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> {\rm iter} = 1 </math>, задание максимального количество итераций <math>{\rm maxiter}</math>'''

'''2a) Нахождение матрицы расстояний '''<math>{\rm dist}:</math>

<math>{\rm dist}_{ij} = \sum_{l = 1\dots d} (x_{il}-\mu_{jl})^2</math>

'''2b) Нахождение вектора распределения объектов по кластерам '''<math>{\rm index}: </math>

<math>{\rm index}_{i} = \underset{j}{\rm argmin }~{\rm 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, {\rm index}_l = i\} </math>

'''4) Проверка критерия останова:'''

'''Если''' <math> \exists i: \tilde{\mu_i} \neq \mu_i</math>, <math> {\rm iter} < {\rm maxiter} </math>,

'''то''' <math> {\rm inc}({\rm iter}), \Mu=\tilde{\Mu},</math> '''GOTO 2.а.'''

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

'''1)''' Сложность инициализации в общем случае зависит от применяемого метода генерации/получения случайных чисел, но ей можно пренебречь

'''2a)''' Вычисление матрицы расстояний требует <math> n\times k\times d </math> операций умножения и <math> n\times k\times (d-1) </math> операций сложения

'''2b)''' Нахождение вектора распределения требует <math> n\times (k-1) </math> операций сравнения

'''3)''' Для вычисления <math> \tilde{\Mu} </math> требуется <math> (n - k + 1) \times d </math> операций сложения и <math> k \times d </math> операций деления

'''4)''' Для критерия останова требуется <math> n\times d </math> сравнений

Итого: так как максимальное количество итераций задается в алгоритме заранее и не зависит от входных данных, то количество итераций ограничено константой. Тогда сложность алгоритма:

* <math> O(n\times k\times d)</math> операций сложения/вычитания
* <math> O(n\times k\times d)</math> операций умножения, <math> O(k\times d) </math> операций деления

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

Рассмотрим вычислительные этапы алгоритма k-means. Это распределение объектов по кластерам и перерасчет центроидов.

Распределение объектов по кластерам состоит из нахождения матрицы расстояний между <math>X</math> и <math>\Mu</math> (этапа '''2a)''') и нахождения индекса минимального элемента в каждой строке (этап '''2b)'''). Ниже приведен информационный граф данного этапа.

[[Файл:EgorovBogomazovInf.png |800px|thumb|center|Нахождение вектора индексов распределения по кластерам]]

Рассмотрим этап вычисления ячейки <math> {\rm 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> {\rm dist} </math> может происходить полностью независимо, так как они находятся на одном ярусе. При рассмотрении операции вычисления значения конкретной ячейки <math> {\rm dist}_{ij} </math> можно заметить, что все операции умножения также независимы между собой, поэтому понадобится всего одно умножение. Конечный результат получается в результате суммирования всех слагаемых и достигается параллельно за <math> \log(d) </math> бинарных операций сложения при помощи стандартного метода ''reduction''.

'''2b)''' Нахождение вектора распределений заключается в нахождении минимального элемента в каждой строке матрицы <math> {\rm 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>{\rm index}</math>, который можно выполнить за <math> n </math> операций косвенных адресаций.

'''4)''' Все сравнения для критерия останова также независимы между собой и могут быть выполнены за одну операцию сравнения, а финальный результат может быть получен за одну операцию сложения при работе над общей памятью (к примеру, прибавление единицы при несовпадении в общую память и сравнение ее с 0 по завершению) или за <math>\log(k\times d)</math> сложений иначе.

Так как количество итераций ограничено константой, то на сложность оно не влияет. В итоге, параллельная сложность алгоритма k-means такова:
* <math> O(\log(n\times 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.

Код собирался под gcc c опцией -fopenmp. В очереди задача не стояла, так как код считался на одном процессоре, hyperthreading не использовался.

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

* число процессоров [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]]

Участник:Илья Егоров/Алгоритм k-средних

2016-12-13T17:05:05Z

Илья Егоров:

{{Assignment|Zhum}}

{{algorithm
| name = Алгоритм k-средних (k-means)
| serial_complexity = <math>O(n\times k\times d)</math>
| input_data = <math>n\times 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}{\rm argmin } \sum_{x \in S_i} ||x-y||^2_E \\ \Mu = \underset{\tilde{\Mu}}{\rm 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}{\rm 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\times k\times d</math> операций умножений и <math>n\times k\times (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> {\rm iter} = 1 </math>, задание максимального количество итераций <math>{\rm maxiter}</math>'''

'''2a) Нахождение матрицы расстояний '''<math>{\rm dist}:</math>

<math>{\rm dist}_{ij} = \sum_{l = 1\dots d} (x_{il}-\mu_{jl})^2</math>

'''2b) Нахождение вектора распределения объектов по кластерам '''<math>{\rm index}: </math>

<math>{\rm index}_{i} = \underset{j}{\rm argmin }~{\rm 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, {\rm index}_l = i\} </math>

'''4) Проверка критерия останова:'''

'''Если''' <math> \exists i: \tilde{\mu_i} \neq \mu_i</math>, <math> {\rm iter} < {\rm maxiter} </math>,

'''то''' <math> {\rm inc}({\rm iter}), \Mu=\tilde{\Mu},</math> '''GOTO 2.а.'''

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

'''1)''' Сложность инициализации в общем случае зависит от применяемого метода генерации/получения случайных чисел, но ей можно пренебречь

'''2a)''' Вычисление матрицы расстояний требует <math> n\times k\times d </math> операций умножения и <math> n\times k\times (d-1) </math> операций сложения

'''2b)''' Нахождение вектора распределения требует <math> n\times (k-1) </math> операций сравнения

'''3)''' Для вычисления <math> \tilde{\Mu} </math> требуется <math> (n - k + 1) \times d </math> операций сложения и <math> k \times d </math> операций деления

'''4)''' Для критерия останова требуется <math> n\times d </math> сравнений

Итого: так как максимальное количество итераций задается в алгоритме заранее и не зависит от входных данных, то количество итераций ограничено константой. Тогда сложность алгоритма:

* <math> O(n\times k\times d)</math> операций сложения/вычитания
* <math> O(n\times k\times d)</math> операций умножения, <math> O(k\times d) </math> операций деления

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

Рассмотрим вычислительные этапы алгоритма k-means. Это распределение объектов по кластерам и перерасчет центроидов.

Распределение объектов по кластерам состоит из нахождения матрицы расстояний между <math>X</math> и <math>\Mu</math> (этапа '''2a)''') и нахождения индекса минимального элемента в каждой строке (этап '''2b)'''). Ниже приведен информационный граф данного этапа.

[[Файл:EgorovBogomazovInf.png |800px|thumb|center|Нахождение вектора индексов распределения по кластерам]]

Рассмотрим этап вычисления ячейки <math> {\rm 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> {\rm dist} </math> может происходить полностью независимо, так как они находятся на одном ярусе. При рассмотрении операции вычисления значения конкретной ячейки <math> {\rm dist}_{ij} </math> можно заметить, что все операции умножения также независимы между собой, поэтому понадобится всего одно умножение. Конечный результат получается в результате суммирования всех слагаемых и достигается параллельно за <math> \log(d) </math> бинарных операций сложения при помощи стандартного метода ''reduction''.

'''2b)''' Нахождение вектора распределений заключается в нахождении минимального элемента в каждой строке матрицы <math> {\rm 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>{\rm index}</math>, который можно выполнить за <math> n </math> операций косвенных адресаций.

'''4)''' Все сравнения для критерия останова также независимы между собой и могут быть выполнены за одну операцию сравнения, а финальный результат может быть получен за одну операцию сложения при работе над общей памятью (к примеру, прибавление единицы при несовпадении в общую память и сравнение ее с 0 по завершению) или за <math>\log(k\times d)</math> сложений иначе.

Так как количество итераций ограничено константой, то на сложность оно не влияет. В итоге, параллельная сложность алгоритма k-means такова:
* <math> O(\log(n\times 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]]

Участник:Илья Егоров/Алгоритм k-средних

2016-12-13T16:53:01Z

Илья Егоров:

{{Assignment|Zhum}}

{{algorithm
| name = Алгоритм k-средних (k-means)
| serial_complexity = <math>O(n\times k\times d)</math>
| input_data = <math>n\times 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}{\rm argmin } \sum_{x \in S_i} ||x-y||^2_E \\ \Mu = \underset{\tilde{\Mu}}{\rm 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}{\rm 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\times k\times d</math> операций умножений и <math>n\times k\times (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>{\rm dist}:</math>

<math>{\rm dist}_{ij} = \sum_{l = 1\dots d} (x_{il}-\mu_{jl})^2</math>

'''2b) Нахождение вектора распределения объектов по кластерам '''<math>{\rm index}: </math>

<math>{\rm index}_{i} = \underset{j}{\rm argmin }~{\rm 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, {\rm 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\times k\times d </math> операций умножения и <math> n\times k\times (d-1) </math> операций сложения

'''2b)''' Нахождение вектора распределения требует <math> n\times (k-1) </math> операций сравнения

'''3)''' Для вычисления <math> \tilde{\Mu} </math> требуется <math> (n - k + 1) \times d </math> операций сложения и <math> k \times d </math> операций деления

'''4)''' Для критерия останова требуется <math> n\times d </math> сравнений

Итого: так как максимальное количество итераций задается в алгоритме заранее и не зависит от входных данных, то количество итераций ограничено константой. Тогда сложность алгоритма:

* <math> O(n\times k\times d)</math> операций сложения/вычитания
* <math> O(n\times k\times d)</math> операций умножения, <math> O(k\times d) </math> операций деления

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

Рассмотрим вычислительные этапы алгоритма k-means. Это распределение объектов по кластерам и перерасчет центроидов.

Распределение объектов по кластерам состоит из нахождения матрицы расстояний между <math>X</math> и <math>\Mu</math> (этапа '''2a)''') и нахождения индекса минимального элемента в каждой строке (этап '''2b)'''). Ниже приведен информационный граф данного этапа.

[[Файл:EgorovBogomazovInf.png |800px|thumb|center|Нахождение вектора индексов распределения по кластерам]]

Рассмотрим этап вычисления ячейки <math> {\rm 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> {\rm dist} </math> может происходить полностью независимо, так как они находятся на одном ярусе. При рассмотрении операции вычисления значения конкретной ячейки <math> {\rm dist}_{ij} </math> можно заметить, что все операции умножения также независимы между собой, поэтому понадобится всего одно умножение. Конечный результат получается в результате суммирования всех слагаемых и достигается параллельно за <math> \log(d) </math> бинарных операций сложения при помощи стандартного метода ''reduction''.

'''2b)''' Нахождение вектора распределений заключается в нахождении минимального элемента в каждой строке матрицы <math> {\rm 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>{\rm index}</math>, который можно выполнить за <math> n </math> операций косвенных адресаций.

'''4)''' Все сравнения для критерия останова также независимы между собой и могут быть выполнены за одну операцию сравнения, а финальный результат может быть получен за одну операцию сложения при работе над общей памятью (к примеру, прибавление единицы при несовпадении в общую память и сравнение ее с 0 по завершению) или за <math>\log(k\times d)</math> сложений иначе.

Так как количество итераций ограничено константой, то на сложность оно не влияет. В итоге, параллельная сложность алгоритма k-means такова:
* <math> O(\log(n\times 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]]

Участник:Илья Егоров/Алгоритм k-средних

2016-12-13T16:49:50Z

Илья Егоров:

{{Assignment|Zhum}}

{{algorithm
| name = Алгоритм k-средних (k-means)
| serial_complexity = <math>O(n\times k\times d)</math>
| input_data = <math>n\times 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}{\rm 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\times k\times d</math> операций умножений и <math>n\times k\times (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\times k\times d </math> операций умножения и <math> n\times k\times (d-1) </math> операций сложения

'''2b)''' Нахождение вектора распределения требует <math> n\times (k-1) </math> операций сравнения

'''3)''' Для вычисления <math> \tilde{\Mu} </math> требуется <math> (n - k + 1) \times d </math> операций сложения и <math> k \times d </math> операций деления

'''4)''' Для критерия останова требуется <math> n\times d </math> сравнений

Итого: так как максимальное количество итераций задается в алгоритме заранее и не зависит от входных данных, то количество итераций ограничено константой. Тогда сложность алгоритма:

* <math> O(n\times k\times d)</math> операций сложения/вычитания
* <math> O(n\times k\times d)</math> операций умножения, <math> O(k\times 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\times d)</math> сложений иначе.

Так как количество итераций ограничено константой, то на сложность оно не влияет. В итоге, параллельная сложность алгоритма k-means такова:
* <math> O(\log(n\times 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]]

Участник:Илья Егоров/Алгоритм k-средних

2016-12-13T16:44:48Z

Илья Егоров:

{{Assignment|Zhum}}

{{algorithm
| name = Алгоритм k-средних (k-means)
| serial_complexity = <math>O(n\times k\times d)</math>
| input_data = <math>n\times 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\times k\times d</math> операций умножений и <math>n\times k\times (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\times k\times d </math> операций умножения и <math> n\times k\times (d-1) </math> операций сложения

'''2b)''' Нахождение вектора распределения требует <math> n\times (k-1) </math> операций сравнения

'''3)''' Для вычисления <math> \tilde{\Mu} </math> требуется <math> (n - k + 1) \times d </math> операций сложения и <math> k \times d </math> операций деления

'''4)''' Для критерия останова требуется <math> n\times d </math> сравнений

Итого: так как максимальное количество итераций задается в алгоритме заранее и не зависит от входных данных, то количество итераций ограничено константой. Тогда сложность алгоритма:

* <math> O(n\times k\times d)</math> операций сложения/вычитания
* <math> O(n\times k\times d)</math> операций умножения, <math> O(k\times 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\times d)</math> сложений иначе.

Так как количество итераций ограничено константой, то на сложность оно не влияет. В итоге, параллельная сложность алгоритма k-means такова:
* <math> O(\log(n\times 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]]

Участник:Илья Егоров/Алгоритм k-средних

2016-11-16T20:19:24Z

Илья Егоров: /* Масштабируемость реализации алгоритма */

{{Assignment}}

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

Участник:Илья Егоров/Алгоритм k-средних

2016-11-16T14:57:14Z

Илья Егоров:

{{Assignment}}

{{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-средних. Параллельная реализация была написана самостоятельно на языке C, [http://git.algowiki-project.org/iaegorov/Egorov-Bogomazov-k-means/tree/master ссылка на реализацию]. Исследование проводилось на суперкомпьютере "Ломоносов" [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-средних. Изменение эффективности алгоритма в зависимости от числа процессоров и размера исходных данных.]]

Здесь построена эффективность перехода от последовательной реализации к параллельной. Рассчитывается она по формуле ''Время вычисления на 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]]

Участник:Илья Егоров/Алгоритм k-средних

2016-11-16T14:56:54Z

Илья Егоров:

{{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-средних. Параллельная реализация была написана самостоятельно на языке C, [http://git.algowiki-project.org/iaegorov/Egorov-Bogomazov-k-means/tree/master ссылка на реализацию]. Исследование проводилось на суперкомпьютере "Ломоносов" [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-средних. Изменение эффективности алгоритма в зависимости от числа процессоров и размера исходных данных.]]

Здесь построена эффективность перехода от последовательной реализации к параллельной. Рассчитывается она по формуле ''Время вычисления на 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]]

Участник:Илья Егоров/Алгоритм k-средних

2016-11-16T14:55:04Z

Илья Егоров: /* Масштабируемость реализации алгоритма */

{{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-средних. Параллельная реализация была написана самостоятельно на языке C, [http://git.algowiki-project.org/iaegorov/Egorov-Bogomazov-k-means/tree/master ссылка на реализацию]. Исследование проводилось на суперкомпьютере "Ломоносов" [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-средних. Изменение эффективности алгоритма в зависимости от числа процессоров и размера исходных данных.]]

Здесь построена эффективность перехода от последовательной реализации к параллельной. Рассчитывается она по формуле ''Время вычисления на 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]]

Участник:Илья Егоров/Алгоритм k-средних

2016-11-16T14:54:16Z

Илья Егоров: /* Масштабируемость реализации алгоритма */

{{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-средних. Параллельная реализация была написана самостоятельно на языке C, [http://git.algowiki-project.org/iaegorov/Egorov-Bogomazov-k-means/tree/master ссылка на реализацию]. Исследование проводилось на суперкомпьютере "Ломоносов" [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-средних. Изменение эффективности алгоритма в зависимости от числа процессоров и размера исходных данных.]]

Здесь построена эффективность перехода от последовательной реализации к параллельной. Рассчитывается она по формуле *Время вычисления на 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]]

Участник:Илья Егоров/Алгоритм k-средних

2016-11-16T14:45:05Z

Илья Егоров: /* Масштабируемость реализации алгоритма */

{{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-средних. Параллельная реализация была написана самостоятельно на языке C, [http://git.algowiki-project.org/iaegorov/Egorov-Bogomazov-k-means/tree/master ссылка на реализацию]. Исследование проводилось на суперкомпьютере "Ломоносов" [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-средних

2016-11-16T14:29:47Z

Илья Егоров: /* Масштабируемость реализации алгоритма */

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

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

* число процессоров [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-средних

2016-11-16T14:28:23Z

Илья Егоров: /* Масштабируемость алгоритма и его реализации */

{{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-средних

2016-11-15T20:59:24Z

Илья Егоров: /* Масштабируемость реализации */

{{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 Суперкомпьютерного комплекса Московского университета].

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

* число процессоров [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-средних

2016-11-15T20:58:42Z

Илья Егоров: /* Масштабируемость реализации */

{{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 Суперкомпьютерного комплекса Московского университета].

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

* число процессоров [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-средних

2016-11-15T20:57:16Z

Илья Егоров: /* Масштабируемость реализации */

{{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 Суперкомпьютерного комплекса Московского университета].

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

* число процессоров [1 : 16] с увеличением в 2 раза;
* размер данных [100000 : 1600000] с увеличением в 2 раза.

В результате проведённых экспериментов были получены следующие данные:

* Максимальная эффективность в точке достигается при переходе от 1 потока на 8 при минимальном размере данных, она равна 87,5%.
* Усредненная максимальная эффективность достигается при переходе с одного потока на два. Среднее время вычислений на всех рассмотренных потока снижается с 16,33 до 11.87 секунд, поэтому формально эффективность <math>= 16,33 / 11,87 / 2 \approx 68,4\%</math>
* Минимальная эффективность в точке достигается при переходе от 1 потока на 16 при размере данных 800000, она равна 11,1%.
* Усредненная минимальная эффективность наблюдается при переходе с одного на максимальное рассматриваемое в эксперименте число потоков, равное 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-средних

2016-11-15T18:04:10Z

Илья Егоров: /* Масштабируемость реализации */

{{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 Суперкомпьютерного комплекса Московского университета].

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

* число процессоров [1 : 16] с увеличением в 2 раза;
* размер данных [100000 : 1600000] с увеличением в 2 раза.

В результате проведённых экспериментов были получены следующие данные:

* Максимальная эффективность достигается при переходе с одного потока на два. Среднее время вычислений снижается с 50 до 32 секунд, поэтому формально эффективность <math>= 50 / 32 / 2 \approx 78\%</math>
* Минимальная эффективность наблюдается при переходе с одного на максимальное рассматриваемое в эксперименте число потоков, равное 16. Время вычисления изменяется с 50 до 20 секунд, поэтому формально эффективность <math> = 50 / 20 / 16 \approx 16\%</math>

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

[[file:Egorov_Bogomazov_Time.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-средних

2016-11-15T18:02:26Z

Илья Егоров: /* Масштабируемость реализации */

{{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 Суперкомпьютерного комплекса Московского университета].

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

* число процессоров [1 : 16] с увеличением в 2 раза;
* размер данных [100000 : 1600000] с увеличением в 2 раза.

В результате проведённых экспериментов были получены следующие данные:

* Максимальная эффективность достигается при переходе с одного потока на два.
Среднее время вычислений снижается с 50 до 32 секунд, поэтому формально эффективность <math>= 50 / 32 / 2 \approx 78\%</math>
* Минимальная эффективность наблюдается при переходе с одного на максимальное рассматриваемое в эксперименте число потоков, равное 16. Время вычисления изменяется с 50 до 20 секунд, поэтому формально эффективность <math> = 50 / 20 / 16 \approx 16\%</math>

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

[[file:Egorov_Bogomazov_Time.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-средних

2016-11-15T18:02:06Z

Илья Егоров: /* Масштабируемость реализации */

{{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 Суперкомпьютерного комплекса Московского университета].

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

* число процессоров [1 : 16] с увеличением в 2 раза;
* размер данных [100000 : 1600000] с увеличением в 2 раза.

В результате проведённых экспериментов были получены следующие данные:

* Максимальная эффективность достигается при переходе с одного потока на два.
Среднее время вычислений снижается с 50 до 32 секунд, поэтому формально эффективность = <math>50 / 32 / 2 \approx 78\%</math>
* Минимальная эффективность наблюдается при переходе с одного на максимальное рассматриваемое в эксперименте число потоков, равное 16. Время вычисления изменяется с 50 до 20 секунд, поэтому формально эффективность = <math>50 / 20 / 16 \approx 16\%</math>

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

[[file:Egorov_Bogomazov_Time.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-средних

2016-11-15T17:33:53Z

Илья Егоров: /* Масштабируемость реализации */

{{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 Суперкомпьютерного комплекса Московского университета].

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

* число процессоров [1 : 16] с увеличением в 2 раза;
* размер данных [100000 : 1600000] с увеличением в 2 раза.

В результате проведённых экспериментов были получены следующие данные

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

[[file:Egorov_Bogomazov_Time.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-средних

2016-11-15T12:28:23Z

Илья Егоров: /* Масштабируемость реализации */

{{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 Суперкомпьютерного комплекса Московского университета].

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

* число процессоров [1 : 16] с увеличением в 2 раза;
* размер данных [100000 : 1600000] с увеличением в 2 раза.

В результате проведённых экспериментов были получены следующие данные

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

[[file:Egorov_Bogomazov_Iterations.jpg|thumb|center|700px|Параллельная реализация алгоритма k-средних. Изменение числа итераций алгоритма в зависимости от числа процессоров и размера исходных данных.]]
[[file:Egorov_Bogomazov_Time.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-средних

2016-11-15T12:27:50Z

Илья Егоров: /* Масштабируемость реализации */

{{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 Суперкомпьютерного комплекса Московского университета].

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

* число процессоров [1 : 16] с увеличением в 2 раза;
* размер данных [100000 : 1600000] с увеличением в 2 раза.

В результате проведённых экспериментов были получены следующие данные

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

[[file:Egorov_Bogomazov_Iterations.jpg|thumb|center|700px|Параллельная реализация алгоритма k-средних. Изменение числа итераций алгоритма в зависимости от числа процессоров и размера исходных данных.]]
[[file:Egorov_Bogomazov_Time.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-средних

2016-11-15T12:23:41Z

Илья Егоров: /* Масштабируемость алгоритма и его реализации */

{{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-средних согласно предложенной [[Scalability methodology|методике]]. Исследование проводилось на суперкомпьютере "Ломоносов" [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета].

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

* число процессоров [1 : 16] с увеличением в 2 раза;
* размер данных [100000 : 1600000] с увеличением в 2 раза.

В результате проведённых экспериментов были получены следующие данные

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

[[file:Egorov_Bogomazov_Iterations.jpg|thumb|center|700px|Параллельная реализация алгоритма k-средних. Изменение числа итераций алгоритма в зависимости от числа процессоров и размера исходных данных.]]
[[file:Egorov_Bogomazov_Time.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-средних

2016-11-15T12:22:56Z

Илья Егоров: /* Масштабируемость реализации */

{{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-средних согласно предложенной [[Scalability methodology|методике]]. Исследование проводилось на суперкомпьютере "Ломоносов" [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета].

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

* число процессоров [1 : 16] с увеличением в 2 раза;
* размер данных [100000 : 1600000] с увеличением в 2 раза.

В результате проведённых экспериментов были получены следующие данные

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

[[file:Egorov_Bogomazov_Iterations.jpg|thumb|center|700px|Рисунок 5. Параллельная реализация алгоритма k-средних. Изменение числа итераций алгоритма в зависимости от числа процессоров и размера исходных данных.]]
[[file:Egorov_Bogomazov_Time.jpg|thumb|center|700px|Рисунок 6. Параллельная реализация алгоритма 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-средних

2016-11-15T12:17:36Z

Илья Егоров: /* Масштабируемость реализации */

{{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-средних согласно предложенной [[Scalability methodology|методике]]. Исследование проводилось на суперкомпьютере "Ломоносов" [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета].

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

* число процессоров [1 : 16] с увеличением в 2 раза;
* размер данных [100000 : 1600000] с увеличением в 2 раза.

В результате проведённых экспериментов были получены следующие данные

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

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

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

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

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

=== Бесплатный доступ ===

'''Десктопные программы'''

* [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-средних

2016-11-15T10:48:13Z

Илья Егоров: /* Масштабируемость алгоритма и его реализации */

{{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-средних согласно предложенной [[Scalability methodology|методике]]. Исследование проводилось на суперкомпьютере "Ломоносов" [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета].

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

* число процессоров [4 : 256] с шагом 4;
* размер данных [100000 : 1600000] с увеличением в 2 раза.

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

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

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

=== Бесплатный доступ ===

'''Десктопные программы'''

* [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-средних

2016-11-13T13:05:19Z

Илья Егоров: /* Свойства алгоритма */

{{Assignment}}

{{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> операций на единицу переданных данных за одну итерацию.

'''Ограничения алгоритма'''

Алгоритм эффективно работает только на небольших объемах данных.

'''Преимущества алгоритма'''
* Простота использования
* Быстрота использования
* Понятность и прозрачность описания
* Обладает вычислительной устойчивостью
* Предрасположенность к распараллеливанию
* Достаточно популярный, поэтому имеет множество реализаций и вариаций

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

* Нет проверки корректности выбора числа кластеров
* Алгоритм чувствителен к количеству кластеров
* Алгоритм чувствителен к выбору начальных элементов в качестве центроидов
* Алгоритм крайне чувствителен к выбросам по данным
* Медленная работа на больших объемах данных

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

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

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

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

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

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

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

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

=== Бесплатный доступ ===

'''Десктопные программы'''

* [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-средних

2016-11-13T12:35:40Z

Илья Егоров:

{{Assignment}}

{{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> операций на единицу переданных данных.

'''Ограничения алгоритма'''

Алгоритм эффективно работает только на небольших объемах данных.

'''Преимущества алгоритма'''
* Простота использования
* Быстрота использования
* Понятность и прозрачность описания
* Обладает вычислительной устойчивостью
* Предрасположенность к распараллеливанию
* Достаточно популярный, поэтому имеет множество реализаций и вариаций

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

* Нет проверки корректности выбора числа кластеров
* Алгоритм чувствителен к количеству кластеров
* Алгоритм чувствителен к выбору начальных элементов в качестве центроидов
* Алгоритм крайне чувствителен к выбросам по данным
* Медленная работа на больших объемах данных

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

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

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

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

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

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

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

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

=== Бесплатный доступ ===

'''Десктопные программы'''

* [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-средних

2016-11-13T12:35:31Z

Илья Егоров:

{Assignment}

{{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> операций на единицу переданных данных.

'''Ограничения алгоритма'''

Алгоритм эффективно работает только на небольших объемах данных.

'''Преимущества алгоритма'''
* Простота использования
* Быстрота использования
* Понятность и прозрачность описания
* Обладает вычислительной устойчивостью
* Предрасположенность к распараллеливанию
* Достаточно популярный, поэтому имеет множество реализаций и вариаций

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

* Нет проверки корректности выбора числа кластеров
* Алгоритм чувствителен к количеству кластеров
* Алгоритм чувствителен к выбору начальных элементов в качестве центроидов
* Алгоритм крайне чувствителен к выбросам по данным
* Медленная работа на больших объемах данных

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

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

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

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

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

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

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

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

=== Бесплатный доступ ===

'''Десктопные программы'''

* [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-средних

2016-11-13T12:34:42Z

Илья Егоров: /* Свойства алгоритма */

{{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> операций на единицу переданных данных.

'''Ограничения алгоритма'''

Алгоритм эффективно работает только на небольших объемах данных.

'''Преимущества алгоритма'''
* Простота использования
* Быстрота использования
* Понятность и прозрачность описания
* Обладает вычислительной устойчивостью
* Предрасположенность к распараллеливанию
* Достаточно популярный, поэтому имеет множество реализаций и вариаций

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

* Нет проверки корректности выбора числа кластеров
* Алгоритм чувствителен к количеству кластеров
* Алгоритм чувствителен к выбору начальных элементов в качестве центроидов
* Алгоритм крайне чувствителен к выбросам по данным
* Медленная работа на больших объемах данных

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

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

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

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

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

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

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

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

=== Бесплатный доступ ===

'''Десктопные программы'''

* [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-средних

2016-11-13T12:34:28Z

Илья Егоров: /* Свойства алгоритма */

{{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> операций на единицу переданных данных.

'''Ограничения алгоритма'''

Алгоритм эффективно работает только на небольших объемах данных.

'''Преимущества алгоритма'''
* Простота использования
* Быстрота использования
* Понятность и прозрачность описания
* Обладает вычислительной устойчивостью
* Предрасположенность к распараллеливанию
* Достаточно популярный, поэтому имеет множество реализаций и вариаций

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

* Нет проверки корректности выбора числа кластеров
* Алгоритм чувствителен к количеству кластеров
* Алгоритм чувствителен к выбору начальных элементов в качестве центроидов
* Алгоритм крайне чувствителен к выбросам по данным
* Медленная работа на больших объемах данных

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

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

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

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

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

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

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

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

=== Бесплатный доступ ===

'''Десктопные программы'''

* [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-средних

2016-11-13T12:34:17Z

Илья Егоров: /* Свойства алгоритма */

{{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> операций на единицу переданных данных.

'''Ограничения алгоритма'''

Алгоритм эффективно работает только на небольших объемах данных.

'''Преимущества алгоритма'''
* Простота использования
* Быстрота использования
* Понятность и прозрачность описания
* Обладает вычислительной устойчивостью
* Предрасположенность к распараллеливанию
* Достаточно популярный, поэтому имеет множество реализаций и вариаций

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

* Нет проверки корректности выбора числа кластеров
* Алгоритм чувствителен к количеству кластеров
* Алгоритм чувствителен к выбору начальных элементов в качестве центроидов
* Алгоритм крайне чувствителен к выбросам по данным
* Медленная работа на больших объемах данных

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

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

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

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

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

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

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

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

=== Бесплатный доступ ===

'''Десктопные программы'''

* [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-средних

2016-11-13T12:33:44Z

Илья Егоров: /* Свойства алгоритма */

{{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> операций на единицу переданных данных.

'''Ограничения алгоритма'''

Алгоритм эффективно работает только на небольших объемах данных.

'''Преимущества алгоритма'''
* Простота использования
* Быстрота использования
* Понятность и прозрачность описания
* Обладает вычислительной устойчивостью
* Предрасположенность к распараллеливанию
* Достаточно популярный, поэтому имеет множество реализаций и вариаций

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

* Нет проверки корректности выбора числа кластеров
* Алгоритм чувствителен к количеству кластеров
* Алгоритм чувствителен к выбору начальных элементов в качестве центроидов
* Алгоритм крайне чувствителен к выбросам по данным
* Медленная работа на больших объемах данных

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

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

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

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

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

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

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

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

=== Бесплатный доступ ===

'''Десктопные программы'''

* [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-средних

2016-11-13T12:29:36Z

Илья Егоров: /* Свойства алгоритма */

{{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>\dfrac{n*k*d}{n*d} = k</math> умножений к объёму данных

'''Ограничения алгоритма'''

Алгоритм эффективно работает только на небольших объемах данных.

'''Преимущества алгоритма'''
* Простота использования
* Быстрота использования
* Понятность и прозрачность описания
* Обладает вычислительной устойчивостью
* Предрасположенность к распараллеливанию
* Достаточно популярный, поэтому имеет множество реализаций и вариаций

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

* Нет проверки корректности выбора числа кластеров
* Алгоритм чувствителен к количеству кластеров
* Алгоритм чувствителен к выбору начальных элементов в качестве центроидов
* Алгоритм крайне чувствителен к выбросам по данным
* Медленная работа на больших объемах данных

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

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

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

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

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

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

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

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

=== Бесплатный доступ ===

'''Десктопные программы'''

* [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-средних

2016-11-03T11:41:28Z

Илья Егоров:

{{Assignment}}

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

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

'''Ограничения алгоритма'''

Алгоритм эффективно работает только на небольших объемах данных.

'''Преимущества алгоритма'''
* Простота использования
* Быстрота использования
* Понятность и прозрачность описания
* Обладает вычислительной устойчивостью
* Предрасположенность к распараллеливанию
* Достаточно популярный, поэтому имеет множество реализаций и вариаций

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

* Нет проверки корректности выбора числа кластеров
* Алгоритм чувствителен к количеству кластеров
* Алгоритм чувствителен к выбору начальных элементов в качестве центроидов
* Алгоритм крайне чувствителен к выбросам по данным
* Медленная работа на больших объемах данных

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

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

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

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

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

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

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

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

=== Бесплатный доступ ===

'''Десктопные программы'''

* [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-средних

2016-11-03T11:36:22Z

Илья Егоров:

{{Assignment}}

{{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:Богомазов Евгений|Евгений Богомазов]]".

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

= ЧАСТЬ. Свойства и структура алгоритмов =
== Общее описание алгоритма ==

Алгоритм кластеризации 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.

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

'''Ограничения алгоритма'''

Алгоритм эффективно работает только на небольших объемах данных.

'''Преимущества алгоритма'''
* Простота использования
* Быстрота использования
* Понятность и прозрачность описания
* Обладает вычислительной устойчивостью
* Предрасположенность к распараллеливанию
* Достаточно популярный, поэтому имеет множество реализаций и вариаций

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

* Нет проверки корректности выбора числа кластеров
* Алгоритм чувствителен к количеству кластеров
* Алгоритм чувствителен к выбору начальных элементов в качестве центроидов
* Алгоритм крайне чувствителен к выбросам по данным
* Медленная работа на больших объемах данных

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

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

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

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

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

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

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

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

=== Бесплатный доступ ===

'''Десктопные программы'''

* [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-средних

2016-10-26T21:15:25Z

Илья Егоров: добавил пустые разделы

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

Страница создана группой "Илья Егоров — Евгений Богомазов".

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

= ЧАСТЬ. Свойства и структура алгоритмов =
== Общее описание алгоритма ==

Алгоритм кластеризации 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.

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

'''Ограничения алгоритма'''

Алгоритм эффективно работает только на небольших объемах данных.

'''Преимущества алгоритма'''
* Простота использования
* Быстрота использования
* Понятность и прозрачность описания
* Обладает вычислительной устойчивостью
* Предрасположенность к распараллеливанию
* Достаточно популярный, поэтому имеет множество реализаций и вариаций

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

* Нет проверки корректности выбора числа кластеров
* Алгоритм чувствителен к количеству кластеров
* Алгоритм чувствителен к выбору начальных элементов в качестве центроидов
* Алгоритм крайне чувствителен к выбросам по данным
* Медленная работа на больших объемах данных

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

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

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

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

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

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

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

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

=== Бесплатный доступ ===

'''Десктопные программы'''

* [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]]

Участник:Илья Егоров

2016-10-21T07:22:00Z

Илья Егоров:

студент ВМК, 619 группа

почта: ilya.a.egorov@gmail.com

Участник:Илья Егоров/Алгоритм k-средних

2016-10-15T20:58:23Z

Илья Егоров:

{{Assignment}}

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

Страница создана группой "Илья Егоров — Евгений Богомазов".

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

= ЧАСТЬ. Свойства и структура алгоритмов =
== Общее описание алгоритма ==

Алгоритм кластеризации 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.

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

'''Ограничения алгоритма'''

Алгоритм эффективно работает только на небольших объемах данных.

'''Преимущества алгоритма'''
* Простота использования
* Быстрота использования
* Понятность и прозрачность описания
* Обладает вычислительной устойчивостью
* Предрасположенность к распараллеливанию
* Достаточно популярный, поэтому имеет множество реализаций и вариаций

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

* Нет проверки корректности выбора числа кластеров
* Алгоритм чувствителен к количеству кластеров
* Алгоритм чувствителен к выбору начальных элементов в качестве центроидов
* Алгоритм крайне чувствителен к выбросам по данным
* Медленная работа на больших объемах данных

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

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

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

=== Бесплатный доступ ===

'''Десктопные программы'''

* [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-средних

2016-10-15T20:58:09Z

Илья Егоров:

{{Assignment}}

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

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

= ЧАСТЬ. Свойства и структура алгоритмов =
== Общее описание алгоритма ==

Алгоритм кластеризации 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.

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

'''Ограничения алгоритма'''

Алгоритм эффективно работает только на небольших объемах данных.

'''Преимущества алгоритма'''
* Простота использования
* Быстрота использования
* Понятность и прозрачность описания
* Обладает вычислительной устойчивостью
* Предрасположенность к распараллеливанию
* Достаточно популярный, поэтому имеет множество реализаций и вариаций

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

* Нет проверки корректности выбора числа кластеров
* Алгоритм чувствителен к количеству кластеров
* Алгоритм чувствителен к выбору начальных элементов в качестве центроидов
* Алгоритм крайне чувствителен к выбросам по данным
* Медленная работа на больших объемах данных

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

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

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

=== Бесплатный доступ ===

'''Десктопные программы'''

* [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-средних

2016-10-15T20:52:19Z

Илья Егоров: /* Информационный граф */

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

Страница создана группой "Илья Егоров — Евгений Богомазов"

= ЧАСТЬ. Свойства и структура алгоритмов =
== Общее описание алгоритма ==

Алгоритм кластеризации 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|Этап 2b]]

Рассмотрим этап вычисления ячейки <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.

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

'''Ограничения алгоритма'''

Алгоритм эффективно работает только на небольших объемах данных.

'''Преимущества алгоритма'''
* Простота использования
* Быстрота использования
* Понятность и прозрачность описания
* Обладает вычислительной устойчивостью
* Предрасположенность к распараллеливанию
* Достаточно популярный, поэтому имеет множество реализаций и вариаций

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

* Нет проверки корректности выбора числа кластеров
* Алгоритм чувствителен к количеству кластеров
* Алгоритм чувствителен к выбору начальных элементов в качестве центроидов
* Алгоритм крайне чувствителен к выбросам по данным
* Медленная работа на больших объемах данных

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

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

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

=== Бесплатный доступ ===

'''Десктопные программы'''

* [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-средних

2016-10-15T20:51:30Z

Илья Егоров: /* Информационный граф */

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

Страница создана группой "Илья Егоров — Евгений Богомазов"

= ЧАСТЬ. Свойства и структура алгоритмов =
== Общее описание алгоритма ==

Алгоритм кластеризации 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.

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

'''Ограничения алгоритма'''

Алгоритм эффективно работает только на небольших объемах данных.

'''Преимущества алгоритма'''
* Простота использования
* Быстрота использования
* Понятность и прозрачность описания
* Обладает вычислительной устойчивостью
* Предрасположенность к распараллеливанию
* Достаточно популярный, поэтому имеет множество реализаций и вариаций

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

* Нет проверки корректности выбора числа кластеров
* Алгоритм чувствителен к количеству кластеров
* Алгоритм чувствителен к выбору начальных элементов в качестве центроидов
* Алгоритм крайне чувствителен к выбросам по данным
* Медленная работа на больших объемах данных

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

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

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

=== Бесплатный доступ ===

'''Десктопные программы'''

* [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-средних

2016-10-15T20:51:10Z

Илья Егоров: /* Информационный граф */

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

Страница создана группой "Илья Егоров — Евгений Богомазов"

= ЧАСТЬ. Свойства и структура алгоритмов =
== Общее описание алгоритма ==

Алгоритм кластеризации 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|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.

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

'''Ограничения алгоритма'''

Алгоритм эффективно работает только на небольших объемах данных.

'''Преимущества алгоритма'''
* Простота использования
* Быстрота использования
* Понятность и прозрачность описания
* Обладает вычислительной устойчивостью
* Предрасположенность к распараллеливанию
* Достаточно популярный, поэтому имеет множество реализаций и вариаций

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

* Нет проверки корректности выбора числа кластеров
* Алгоритм чувствителен к количеству кластеров
* Алгоритм чувствителен к выбору начальных элементов в качестве центроидов
* Алгоритм крайне чувствителен к выбросам по данным
* Медленная работа на больших объемах данных

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

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

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

=== Бесплатный доступ ===

'''Десктопные программы'''

* [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]]

Файл:EgorovBogomazovNewCluster.png

2016-10-15T20:47:06Z

Илья Егоров: Илья Егоров загрузил новую версию Файл:EgorovBogomazovNewCluster.png

Файл:EgorovBogomazovNewCluster.png

2016-10-15T20:42:40Z

Илья Егоров:

Файл:EgorovBogomazovDist.png

2016-10-15T20:41:22Z

Илья Егоров: