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

Участник:Шишков Илья Сергеевич/Алгоритм HCM (Hard C – Means)

2016-12-16T13:04:12Z

Coctic:

{{Assignment|{{REVISIONUSER}}}}
{{algorithm
| name = Алгоритм HCM (Hard C – Means)
| serial_complexity = <math>O(ncK)</math>
| pf_height = <math>O(1)</math>
| pf_width = <math>O(cK)</math>
| input_data = <math>O(nK)</math>
| output_data = <math>O(c(K+n))</math>
}}

Основные авторы описания: [[Участник:Шишков_Илья_Сергеевич|Илья Шишков]] (1.1-1.4, 2.7, 2.4), [[Участник:Темербекова_Гульгайша|Гульгайша Темербекова]] (1.5-1.10, 3, 2.4)

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

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

Алгоритм HCM (Строгий алгоритм С-средних) был предложен группой исследователей(Jang, Sun and Mizutani) в 1997 и относится к классу алгоритмов со строгой кластеризаций.

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

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

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

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

Алгоритм HCM является итеративным и состоит из нескольких шагов:

1.'''Инициализация: '''

Случайным образом определяются C векторов - центров кластеров

2. '''Расчет рядовой матрицы:'''

В процессе расчета рядовой матрицы каждый вектор сравнивается с ближайшим кластерным центром

3. '''Расчет оценочной функции:'''

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

4. '''Переопределение кластерных центров'''

Пункты 2-4 выполняются до тех пор, пока в пункте 3 проверка не станет успешной.

=== Математическое описание алгоритма <ref>Arabinda Panda & Satchidananda Dehuri. Hard C-means Clustering Algorithm in Gene Expression Data // International Journal on Advanced Computer Theory and Engineering, ISSN-PRINT: 2319-2526. - 2013. - v. 2. - p. 35-39 [http://www.irdindia.in/journal_ijacte/pdf/vol2_iss1/8.pdf]</ref> ===

Обозначения

<math>U</math> - наборы данных

<math>u_{i}</math> - i-ый набор из <math>U</math>

<math>u</math> - любой набор из <math>U</math>

<math>K</math> - количество наборов в <math>U</math>

<math>c_{j}</math> - j-ый кластер

<math>c</math> - количество кластеров

<math>c_{j}</math> - j-ый кластерный центр

<math>c^*_{j}</math> - j-ый кластерный центр после обновления

Выходные данные:
<math>c^*_{1}, c^*_{2}, ... c^*_{c}, M</math>

Объектная функция:

<math>J=\sum_{j = 1}^{c} \sum_{u_{i} \in C_{j}}^{} \|u_{i}-c_{j}\|^2, j \in 1,2, ... c, i={1,2, ...K}</math>

'''Шаг 1'''

Из входного набора <math>u_{1},u_{2}, ... u_{n}</math> выбираются <math>c</math> начальных кластерных центра <math> c_{1},c_{2},...,c_{c}</math>либо случайным образом, либо с использованием заранее определенного алгоритма

'''Шаг 2'''

Рассчитывается рядовая матрица <math> M=\|m_{ik}\|</math> каждый элемент которой вычисляется по следующей формуле:
:<math>
m_{ik} = \begin{cases}
1, & \|u_k-c_i\|^2 \leqslant \|u_k-c_j\|^2 \;\; \text{for all } i \neq j; \;\; (i,j=1,2,\ldots,c; \; k = 1,2,\ldots,K)\\
0, & \text{other}.
\end{cases}
</math>

'''Шаг 3'''

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

'''Шаг 4'''

Рассчитываются новые кластерные центры по следующей формуле:

<math> c^*_{j} = \frac{1}{|C_{j}|} \sum_{u_{i} \in C_{j}}^{} c_{i}, j=1,2,3..,c</math>

где <math>|C_{j}| </math> - число элементов, принадлежащих кластеру <math>C_{j}</math>

'''Шаг 5'''

Если алгоритм не завершил свою работу на шаге 3 то переходим к шагу 2.

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

Вычислительным ядром данного алгоритма является вычисление на каждой итерации алгоритма квадратов норм между кластерными центрами и векторами из входного набор согласно формуле <math>\|u_k-c_i\|^2</math>. На каждой итерации алгоритма происходит <math>cK</math> таких вычислений.

=== Макроструктура алгоритма ===
Основной операцией алгоритма является операция нахождения квадратов расстояний между исходными векторами и кластерными центрами.

<math>
\|u_k-c_i\|^2
</math>

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

<math>J=\sum_{j = 1}^{c} \sum_{u_{i} \in C_{j}}^{} \|u_{i}-c_{j}\|^2, j \in 1,2, ... c, i={1,2, ...K}</math>

При перерасчете кластерных центров происходит суммирование векторов:

<math> c^*_{j} = \frac{1}{|C_{j}|} \sum_{u_{i} \in C_{j}}^{} u_{i}, j=1,2,3..,c</math>

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

Последовательность исполнения метода следующая <ref> Jyh-Shing Roger Jang, Chuen-Tsai Sun, Eiji Mizutani. Neuro-fuzzy and soft computing: a computational approach to learning and machine intelligence. Prentice-Hall, Inc. Simon & Schuster/A Viacom Company Upper Saddle River, NJ 07458. - 1997. - p. 424. [http://it-claim.ru/Persons/Neyskiy/Article2_Neiskiy.pdf]</ref>:

1. Инициализация кластерных центров <math>c_i \, (i=1,2,\ldots,c)</math>. Это можно сделать выбрав случайным образом <math>c</math> – векторов из входного набора.

2. Вычисление рядовой матрицы <math>M</math>:
:<math>
m_{ik} = \begin{cases}
1, & \|u_k-c_i\|^2 \leqslant \|u_k-c_j\|^2 \;\; \text{for all } i \neq j; \;\; (i,j=1,2,\ldots,c; \; k = 1,2,\ldots,K) \\
0, & \text{other}.
\end{cases}
</math>
где К – количество элементов во входном наборе данных.

Матрица <math>M</math> обладает следующими свойствами:
:<math>
\sum\limits_{i=1}^c m_{ij} = 1, \;\; \sum\limits_{j=1}^K m_{ij} = K.
</math>

3. Расчёт объектной функции:
:<math>
J = \sum\limits_{i=1}^c J_i = \sum\limits_{i=1}^c \left( \sum\limits_{k:\, u_k \in C_i} \|u_k -c_i \|^2 \right)
.</math>

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

4. Пересчёт кластерных центров выполняется в соответствии со следующим уравнением:
:<math>
c_i = \frac{1}{|C_i|} \sum\limits_{k:\, u_k \in C_i} u_k,
</math>
где под <math>|C_i|</math> подразумевается количество элементов в <math>i</math>-ом кластере.

5. на шаг 2.

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

Для каждой итерации алгоритма требуется:
* <math>ncK</math> умножений,
* <math>ncK</math> вычитаний,
* <math>K(cn+1)</math> сложений,
* <math>K(c-1)</math> сравнений.

Умножения, сложения (вычитания), сравнения составляют ''основную часть алгоритма''.

Итоговая сложность последовательной реализации алгоритма <math>O(ncK)</math> <ref> Pawan Kumar, Mr. Pankaj Verma, Rakesh Sharma. Comparative analysis of Fuzzy C-mean and Hard C-mean algorithm // International Journal of information Technology and Knowledge Management. - July-December 2010. - v. 2 [http://csjournals.com/IJITKM/PDF%203-1/39.pdf]</ref>. Обычно <math>n</math>, <math>c</math> значительно меньше, чем <math>K</math>.

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

Граф алгоритма состоит из пяти групп вершин.

'''Первая''' группа вершин '''''<math>c_1,...,c_c</math>''''' - прямое вычисление расстояния до кластерных центров, то есть вычисление расстояний от заданного элемента <math>u_i</math> до каждого из кластерных центров.

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

'''Третья''' группа вершин '''''M''''' - ей соответствует операция записи единички в столбец матрицы.

'''Четвертая''' группа вершин '''''J''''' - вычисление объектной функции, происходит проверка условия достижения необходимой точности, если достигли заданной точности то переход в '''''Out''''', в противном случае '''''Conversion'''''.

'''Пятая''' группа вершин '''''Conversion''''' - пересчёт кластерных центров и переход на следующую итерацию.

На рисунке изображена одна итерация алгоритма.

[[File:Picture.png|thumb|600px|center|Рисунок 1. '''''in''''' - входные данные, '''''<math>c_1,...,c_c</math>''''' - вычисление расстояния до кластерных центров и значение <math>u_i</math> единое для каждой группы '''''<math>c_1,...,c_c</math>''''', '''''min''''' - нахождение минимального расстояния до кластерных центров, '''''M''''' - запись единички в столбец матрицы, '''''J''''' - расчёт объектной функции, '''''Conversion''''' — пересчёт кластерных центров, '''''out''''' — вывод полученных данных.]]

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

Для одной итерации алгоритма в параллельном варианте требуется <math>K</math> раз последовательно выполнить для каждого <math>u_i</math> следующие ярусы:
* <math>C</math> операций нахождения расстояния от элемента <math>u_i</math> до каждого из кластерных центров.
* <math>C-1</math> сравнений, для нахождения минимального расстояния.
* операция записи единички в столбец матрицы <math>M</math>.

Основным ресурсом алгоритма является вычисление квадрата нормы для каждого <math>u_i</math>. Расчёт значения объектной функции <math>J</math> сложно представить в параллельном варианте, поэтому вычисление объектной функции производится последовательно.Использование параллельной реализации алгоритма приведёт к понижению производительности при небольшой размерности системы и малом объеме выборки. При параллельном варианте необходима пересылка данных, что при малом объеме выборки и небольшой размерности займет больше времени, чем при последовательном варианте.
Как легко видеть из информационного графа, высота [[глоссарий#Ярусно-параллельная форма графа алгоритма|ЯПФ]] составляет <math>O(1)</math>, ширина ЯПФ составляет <math>O(cK)</math>, если число итераций меньше объема выборки.

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

'''Входные данные:'''
# <math>\{u_k\}_{k=1}^{K}</math> — исходный набор векторов, принадлежащие пространству <math>\mathbb{R}^n</math>;
# <math>c</math> — количество кластеров;

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

'''Выходные данные:'''
# <math>M</math> — матрица, принадлежащая пространству <math>\mathbb{R}^{c \times K}</math>.
# <math>\{c^*_i\}_{i=1}^{c}</math> — набор построенных кластерных центров.

'''Объём выходных данных:''' <math>c(K+n)</math>.

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

'''Назначение:''' кластеризация больших наборов числовых данных.

'''Достоинства:''' легкость реализации,вычислительная простота.

'''Недостатки:''' задание количества кластеров,отсутствие гарантии в нахождении оптимального решения.

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
==== Локальность реализации алгоритма ====
===== Структура обращений в память и качественная оценка локальности =====
===== Количественная оценка локальности =====
=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===
==== Масштабируемость алгоритма ====
==== Масштабируемость реализации алгоритма ====
Проведём исследование масштабируемости параллельной реализации алгоритма Hard C - Means (HCM). Исследование проводилось на суперкомпьютере "Ломоносов" [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета] с пиковой производительностью 1,7 Пфлопс, число процессоров/ядер x86: 12 346 / 52 168. Программа написана на языке C с использованием [https://parallel.ru/cluster/lomonosov_howto MPI], не использовалось дополнительных опций. Использовалась следующая [https://github.com/cNikolaou/mpi-kmeans параллельная реализация алгоритма HCM].
Компилятор: gcc.
Версия MPI - intel openmpi/1.8.4-icc.
Модель используемого CPU - Intel Xeon X5570 2.93GHz.

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

* число ядер <math>[16 : 256]</math> с шагом по степеням двойки;
* объём выборки <math>[10^3:10^7]</math> с шагом по степеням десятки;

На рисунке приведена параллельная реализация алгоритма Hard C - Means (HCM). Изменение вычислительного времени алгоритма в зависимости от числа ядер и размера исходных данных.

[[Файл:scheme1.png]]

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

* [https://github.com/artpar/Hard-Clustering-implementation Последовательная реализация на С++ ]

* [http://projects.jasmeet.me/2013/03/HardCMeans.html Последовательная реализация на MatLab ]

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

Обсуждение участника:Шишков Илья Сергеевич

2016-12-16T13:04:00Z

Coctic:

= Статья [[Алгоритм HCM (Hard C – Means)]] =
* Не указан вклад каждого автора [[Участник:Coctic|Coctic]] ([[Обсуждение участника:Coctic|обсуждение]]) 10:47, 25 октября 2016 (MSK)
** Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 11:06, 1 ноября 2016 (MSK)
* п. 1.1 Стоит добавит ссылку на публикацию, в которой алгоритм был впервые описан (Jang, Sun and Mizutani) [[Участник:Coctic|Coctic]] ([[Обсуждение участника:Coctic|обсуждение]]) 10:47, 25 октября 2016 (MSK)
* Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 11:06, 1 ноября 2016 (MSK)
* п. 1.3 Сказано, что "На каждой итерации алгоритма происходит <math>CN</math> таких вычислений", однако определений C и N не приведено ни здесь, ни ранее. Ранее имеется определение для c (c малого), но это другой символ. [[Участник:Coctic|Coctic]] ([[Обсуждение участника:Coctic|обсуждение]]) 10:47, 25 октября 2016 (MSK)
** Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 11:06, 1 ноября 2016 (MSK)
* Ссылки в списке литературы не содержат данных публикации, кроме названия и списка авторов. Веб-ссылки на какую-то версию публикации недостаточно. [[Участник:Coctic|Coctic]] ([[Обсуждение участника:Coctic|обсуждение]]) 10:52, 25 октября 2016 (MSK)
** Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 11:06, 1 ноября 2016 (MSK)
** Замечания были приняты и исправлены огрехи. [[Участник:Темербекова_Гульгайша|Темербекова_Гульгайша]] ([[Обсуждение участника:Темербекова_Гульгайша|обсуждение]]) 23:40, 31 октября 2016 (MSK)

* Отсутствует п. 2.4. [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 16:54, 16 ноября 2016 (MSK)
** Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 17:42, 13 декабря 2016 (MSK)
* Необходимо указать характеристики программно-аппаратной платформы (какой компилятор, с какими опциями использовался, какие версии библиотек, на каких узлах проводился запуск и т.д.). Указано, что запуск осуществлялся на Ломоносове, ссылка на MPI приведена на страницы, описывающие BlueGene/P, понять, какая реализация MPI использовалась, невозможно [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 17:42, 13 декабря 2016 (MSK)
** Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 16:03, 16 декабря 2016 (MSK)
* На неподписанном рисунке в п. 2.4. в подписи к оси аппликат указано, что по ней отложено время в секундах, в абзаце перед рисунком указано, что приведен график производительности. Что из этого верно, неясно. [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 17:42, 13 декабря 2016 (MSK)
** Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 16:03, 16 декабря 2016 (MSK)

Участник:Smirnov.maxim/BIRCH

2016-12-13T14:44:21Z

Coctic:

{{Assignment|{{REVISIONUSER}}}}
Авторы: [[Участник:Светлана Морозова|Морозова Светлана]], [[Участник:Smirnov.maxim|Смирнов Максим]].
Вклад авторов:

Смирнов Максим:
*п.1.5
*п.1.7
*п.1.8
*п.1.9
*п.2.7

Морозова Светлана
*п.1.1
*п.1.2
*п.1.3
*п.1.4
*п.1.6
*п.1.10
*п.3

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

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

Нахождение полезных для анализа закономерностей в больших объёмах данных с недавних пор вызывает значительный интерес. В связи с этим ввелось и стало активно развиваться такое понятие как ''[https://ru.wikipedia.org/wiki/%D0%9A%D0%BB%D0%B0%D1%81%D1%82%D0%B5%D1%80%D0%BD%D1%8B%D0%B9_%D0%B0%D0%BD%D0%B0%D0%BB%D0%B8%D0%B7 кластеризация]''.

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

'''BIRCH'''<ref>Нейский И.М. Классификация и сравнение методов кластеризации // Интеллектуальные технологии и системы. Сборник учебно-методических работ и статей аспирантов и студентов. – М.: НОК «CLAIM», 2006. – Выпуск 8. – С. 130-142.</ref><ref>T Zhang, R Ramakrishnan, M Livny. BIRCH: An Efficient Data Clustering Method for Very Large Databases - 1996. - С.103-114)</ref> - алгоритм, применяемый в области [https://ru.wikipedia.org/wiki/Data_mining Data mining] и использующий принципы [https://ru.wikipedia.org/wiki/%D0%98%D0%B5%D1%80%D0%B0%D1%80%D1%85%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B0%D1%8F_%D0%BA%D0%BB%D0%B0%D1%81%D1%82%D0%B5%D1%80%D0%B8%D0%B7%D0%B0%D1%86%D0%B8%D1%8F иерархической кластеризации].

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

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

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

=== Теоретическая основа ===

Пусть в кластере имеются <math>N</math> точек размерности <math>d</math>: <math>\{\vec{X_i}\}, i=1,2,...,N</math>.
Тогда '''центроид''' <math>{\vec{{X_0}}}</math>, '''радиус''' <math>R</math> и '''диаметр''' <math>D</math> кластера определяются следующим образом:

<math>{\vec{X_0}}=\frac{\sum_{i=1}^N\vec{X_i}}{N}</math>

<math>R = (\frac{\sum_{i=1}^N{(\vec{X_i} - \vec{X_0})}^2}{N})^{1/2}</math>

<math>D = (\frac{\sum_{i=1}^N\sum_{j=1}^N{(\vec{X_i} - \vec{X_j})}^2}{N(N-1)})^{1/2}</math>

<math>R</math> - это среднее расстояние от каждой точки до центроида. <math>D</math> - это среднее расстояние между парами в кластере. Данные величины являются альтернативными метриками плотности кластера относительно центроида.

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

пусть даны центроиды двух кластеров <math>\vec{X_{01}}</math> и <math>\vec{X_{02}}</math>.
Евклидова метрика <math>D_0</math> и метрика Манхэттена <math>D1</math> между двумя кластерами определяются следующим образом:

<math>D_0 = ((\vec{X_{01}}-\vec{X_{02}})^2)^{1/2}</math>

<math>D_1 = |\vec{X_{01}}-\vec{X_{02}}| = \sum_{i=1}^d |{\vec{X_{01}}}^{(i)}-{\vec{X_{02}}}^{(i)}| </math>

Пусть имеются два кластера, содержащих соответственно <math>N_1</math> и <math>N_2</math> точек размерности <math>d</math>: <math>\{\vec{X_i}\}</math>, где <math>i= 1,2, ...,N_1</math> и <math>\{\vec{X_j}\}</math>, где <math>j= N_1+1,N_1+2, ...,N_1+N_2</math>.

'''Среднее расстояние''' <math>D_2</math>, '''среднее внутрикластерное расстояние''' <math>D_3</math> и '''дисперсия''' <math>D_4</math> для двух кластеров определяются следующим образом:

<math>D_2 = (\frac{\sum_{i=1}^{N_1}\sum_{j=N_1+1}^{N_1+N_2}{(\vec{X_i} - \vec{X_j})}^2}{N_1N_2})^{1/2}</math>

<math>D_3 = (\frac{\sum_{i=1}^{N_1+N_2}\sum_{j=1}^{N_1+N_2}{(\vec{X_i} - \vec{X_j})}^2}{(N_1+N_2)(N_1+N_2-1)})^{1/2}</math>

<math>D_4 = \sum_{k=1}^{N_1+N_2}(\vec{X_k} - \frac{\sum_{i=1}^{N_1+N_2}\vec{X_i}}{N_1+N_2})^2 - \sum_{i=1}^{N_1}(\vec{X_i} - \frac{\sum_{i=1}^{N_1}\vec{X_i}}{N_1})^2 - \sum_{j=N_1+1}^{N_1+N_2}(\vec{X_j} - \frac{\sum_{i=N_1+1}^{N_1+N_2}\vec{X_i}}{N_2})^2</math>

Таким образом, величины <math>\vec{X_0}</math>, <math>R</math> и <math>D</math> относятся к отдельным кластерам, а <math>D_0</math>, <math>D_1</math>, <math>D_2</math>, <math>D_3</math> и <math>D_4</math> - к объединению двух кластеров.

=== Кластерный элемент и кластерное дерево ===

В основе концепции алгоритма BIRCH лежат понятия '''кластерного элемента''' и '''кластерного дерева (CF Tree)'''.

====Кластерный элемент ====

''Определение.'' Пусть в кластере содержатся <math>N</math> точек размерности <math>d</math>:<math>\{\vec{X_i}\}</math>, где <math>i=1,2,...,N</math>.
'''Кластерный элемент (CF)''' - тройка чисел, характеризующая информацию о кластере:
<math>CF = (N, \vec{LS}, SS)</math>, где <math>N</math> - количество элементов входных данных, содержащихся в кластере, <math>\vec{LS}</math> - линейная сумма входных данных (т.е. <math>\sum_{i=1}^{N}\vec{X_i}</math>), <math>SS</math> - сумма квадратов входных данных (т.е. <math>\sum_{i=1}^{N}{\vec{X_i}}^2</math>)

'''Теорема''' Пусть <math>CF_1 = (N_1, \vec{LS_1}, SS_1)</math> и <math>CF_2 = (N_1, \vec{LS_2}, SS_2)</math> - CF векторы двух непересекающихся кластеров. Тогда при их объединении образуется кластер со следующим CF вектором:

<math>CF = CF_1 + CF_2 = (N_1+N_2, \vec{LS_1}+\vec{LS_2}, SS_1+SS_2)</math>.

Из указанных выше определения и теоремы вытекает тот факт, что при объединении кластеров их CF вектор может вычисляться инкрементно и точно.
Легко показать, что вычислить величины <math>\vec{X_0}</math>, <math>R</math>, <math>D</math>, <math>D_0</math>, <math>D_1</math>, <math>D_2</math>, <math>D_3</math>, <math>D_4</math>, как и обычные метрики, также не составит труда.

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

==== Кластерное дерево ====

''Определение.'' '''Кластерное дерево (CF Tree)''' - это взвешенно сбалансированное дерево с двумя параметрами: <math>B</math> - коэффициент разветвления, <math>T</math> - пороговая величина.

Каждый нелистьевой узел дерева имеет не более чем <math>B</math> вхождений узлов следующей формы: <math>[CF_i,child_i]</math>, где <math>i=1,2,...,B</math>, ''child'' - указатель на i-й дочерний узел, <math>CF_i</math> - CF вектор соответствующего подкластера.

Каждый листьевой узел имеет ссылку на два соседних узла (''prev'' и ''next'') для того, чтобы связать все узлы для эффективного сканирования.
Все листьевые узлы должны удовлетворять пороговому ограничению <math>T</math>, т.е. диаметр (радиус) не должен превосходить <math>T</math>.
В процессе вставки новых данных CF дерево строится динамически. Оно использует вставку данных для кластеризации точно также как <math>B+</math> [https://ru.wikipedia.org/wiki/B%2B-%D0%B4%D0%B5%D1%80%D0%B5%D0%B2%D0%BE дерево] использует её для поиска.
CF дерево очень компактно, поскольку каждый листьевой узел - это не просто точка, а подкластер (который объединяет множество точек с учётом ограничения <math>T</math>).

==== Операция вставки в '''CF''' дерево ====

Опишем алгоритм вставки элемнта <math>Ent</math> в CF дерево:

1) ''Определение подходящего листа'': Начиная с корня, алгоритм рекурсивно спускается по CF дереву, выбирая '''ближайший''' дочерний узел в соответствии с выбранной метрикой <math>D0</math>, <math>D1</math>, <math>D2</math>, <math>D3</math> или <math>D4</math>.

2) ''Преобразование листа'': Когда алгоритм доходит до листа, он находит ближайшую листьевой элемент, скажем, <math>L_1</math>, а затем проверяет, можно ли добавить ''Ent'' к <math>L_1</math> без нарушения порогового условия. Если да, то с учётом этого изменяется CF вектор для <math>L_1</math>; если нет, то ''Ent'' становится новым элементом листа. Если в листе для этого достаточно места, то шаг окончен, иначе он должен "расщепиться". Расщепление узла производится при помощи выбора за основу наиболее удалённой друг от друга пары элементов и перераспределение оставшихся элементов в соответствии с выбранным критерием близости.

3) ''Преобразование пути к листу'': После вставки ''Ent'' в лист мы должны обновить информацию о CF для каждого нелистьевого элемента на пути к листу. При отсутствии расщепления это означает простое сложение CF векторов для отражения факта добавления ''Ent''. Расщепление листа же требует вставки нового нелистьевого элемента в родительский узел для задания только что созданного листа. Если у родителя есть место для этого элемента, то необходимо просто преобразовать CF векторы на всех более высоких уровнях. В общем случае, однако, нам также придётся расщепить родительский узел, и так далее до корня. Если расщеплён корень, то высота дерева увеличивается на единицу.

4) ''Улучшение слияния'': Расщепление вызвано ограничением на размер узла, который не зависит от кластеризационных свойств данных. Если во входящем потоке присутствуют "искажённые" (из областей с низкой плотностью) данные, это может повлиять на качество кластеризации, а также уменьшить эффективность использования памяти. Дополнительный шаг алгоритма помогает решить эти проблемы: предположим, что произошло расщепление листа, и распространение этого процесса остановилось на некотором нелистьевом узле <math>N_j</math>, то есть <math>N_j</math> может вместить дополнительный элемент, полученный после расщепления. Теперь мы сканируем узел <math>N_j</math> для нахождения двух наиболее близких элементов. Если это не пара, отвечающая расщеплению, мы пытаемся объединить их и поставить в соответствие два дочерних узла. Если количество элементов в дочерних узлах больше B, мы снова расщепляем результат объединения.
В процессе повторного расщепления, в случае, если один источник собирает достаточно элементов для того, чтобы полностью заполнить узел, оставшиеся элементы передаются другом источнику. В итоге, если объединённые элементы помещаются в одном узле, в нём освобождается место для ещё одного элемента. Тем самым увеличивается степень использования свободного пространства и откладывается дальнейшее расщепление. В ином случае мы улучшаем распределение элементов в двух ближайших подкластерах.

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

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

* радиуса <math>R</math> или диаметра <math>D</math> кластерного элемента. Выполняется при попытке вставить новый элемент в один из подкластеров листьевого узла дерева.

* расстояния между двумя элементами. Выполняется при поиске ближайшего по отношению к новому элементу подкластера в узле дерева по одной из рассмотренных в разд. 1.2.1 метрик <math>D_0</math>, <math>D_1</math>, <math>D_2</math>, <math>D_3</math> или <math>D_4</math>.

Зная характеристики кластерных элементов <math>N</math>, <math>\vec{LS}</math> и <math>S</math>, в результате алгебраических преобразований можно получить следующие упрощенные формулы вычисления необходимых значений:

<math>\vec{X_0} = \frac{\vec{LS}}{N}</math>

<math>R = (\frac{SS - 2\vec{X_0}\vec{LS} + N(\vec{X_0})^2}{N})^{1/2}</math>

<math>D = (\frac{2(N \cdot SS - (\vec{LS})^2)}{N(N-1)})^{1/2}</math>

<math>D_2 = (\frac{N_1 \cdot SS_2 + N_2 \cdot SS_1 - 2\vec{LS_1}\vec{LS_2}}{N_1 \cdot N_2})^{1/2}</math>

<math>D_3 = (\frac{2((N_1+N_2)(SS_1+SS_2)-(\vec{LS_1}+\vec{LS_2})^2)}{(N_1+N_2)(N_1+N_2-1)})^{1/2}</math>

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

Реализация алгоритма BIRCH состояит из следующих четырёх фаз:

* '''Фаза 1'''. Главной задачей фазы 1 является сканирование всех данных и построение в памяти исходного CF дерева, используя заданное количество памяти. Это дерево стремится отразить информацию о кластеризации данных настолько хорошо, насколько это позволяют ограничения по памяти. При этом плотно распределённые данные группируются в подкластеры, а более разрозненные данные удаляются. После завершения фазы 1 вспомогательные вычисления в дальнейших фазах будут:

1) быстрее, потому что (а) больше не нужны операции ввода-вывода, (b) проблема кластеризации начальных данных упрощается до проблемы кластеризации подкластеров в листьях;

2) точнее, потому что (а) большинство данных с низкой плотностью удалены, (b) оставшиеся данные распределены оптимально (в соответствии с доступным количеством памяти);

* '''Фаза 2'''. Данная фаза является опциональной. Известно, что существующие методы глобальной кластеризации, используемые в рамках фазы 3, имеют различные диапазоны входных значений, при которых их реализация наиболее эффективна. Поэтому потенциально существует пробел между размером фазы 1 и входными значениями фазы 3. И фаза 2 как раз является недостающим связующим звеном: так же как и фаза 1, она сканирует листьевые элементы начального CF дерева для того, чтобы построить меньшее дерево, удаляя ещё больше элементов с низкой плотностью и группируя переполненные подкластеры в большие кластеры.

* '''Фаза 3'''. В данной фазе для листьевых элементов применяется (любой подходящий) алгоритм глобальной кластеризации. Существующие алгоритмы кластеризации наборов точек могут также работать с наборами подкластеров, каждый из которых представлен своим CF вектором. Зная CF вектор, можно вычислить центроид и в дальнейшем заменить всю информацию о кластере этим значением (этого достаточно для вычисления большинства необходимых метрик). После фазы 3 мы получаем набор кластеров, который отражает основные характеристики распределяемых данных.
Однако, всё ещё могут оставаться некоторые неточности, для устранения которых существует фаза 4.

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

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

<source lang="c++">
void CF_Node::insert(const CF_Cluster &entry)
{
//Находим ближайший к новому элементу подкластер в узле
СF_Vector_it closest = entry.findClosest(subclusters);
//Если узел пустой, добавляем в него новый подкластер
if (closest == subclusters.end()) {
subclusters.push_back(entry);
return;
}
closest->add(entry);
//Если узел является листьевым, и ближайший подкластер не может вместить
//новый элемент, добавляем в узел новый подкластер
if (leaf) {
if (closest->D > threshold) {
closest->remove(entry);
subclusters.push_back(entry);
}
}
else {
CF_Node *node = closest->child;
node->insert(entry);
//Если при добавлении нового элемента в дочерний узел тот переполнился,
//расщепляем его
if (node->getSubclusters().size() > bFactor) {
CF_Vector newClusters = node->splitNode();
delete node;
subclusters.erase(closest);
subclusters.insert(subclusters.end(), newClusters.begin(), newClusters.end());
}
}
//Если узел является корневым и он переполнен, расщепляем его
if (root && subclusters.size() > bFactor) {
subclusters = splitNode();
leaf = false;
}
}

CF_Vector CF_Node::splitNode()
{
if (subclusters.size() < 2)
return (root) ? subclusters : CF_Vector{CF_Cluster(this)};
//Находим пару наиболее удаленных друг от друга подкластеров
CF_Vector_it pole1, pole2;
data_t longestDist = 0.0;
for (auto lhs = subclusters.begin(); lhs != subclusters.end() - 1; ++lhs) {
for (auto rhs = lhs + 1; rhs != subclusters.end(); ++rhs) {
auto distance = getDistance(*lhs, *rhs);
if (distance > longestDist) {
longestDist = distance;
pole1 = lhs;
pole2 = rhs;
}
}
}
//Разделяем множество всех подкластеров узла на две части
CF_Vector subclusters1, subclusters2;
for (auto it = subclusters.begin(); it != subclusters.end(); ++it) {
if (getDistance(*it, *pole1) < getDistance(*it, *pole2))
subclusters1.push_back(*it);
else
subclusters2.push_back(*it);
}
//Создаем два новых узла
CF_Node *node1 = new CF_Node(threshold, bFactor, count, leaf, subclusters1),
*node2 = new CF_Node(threshold, bFactor, count, leaf, subclusters2);
//Связываем листья
if (leaf) {
if (prevLeaf) {
node1->setPrevLeaf(prevLeaf);
prevLeaf->setNextLeaf(node1);
}
if (nextLeaf) {
node2->setNextLeaf(nextLeaf);
nextLeaf->setPrevLeaf(node2);
}
node1->setNextLeaf(node2);
node2->setPrevLeaf(node1);
}
CF_Cluster cluster1(node1), cluster2(node2);
return CF_Vector{cluster1, cluster2};
}
</source>

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

Для начала проанализируем вычислительную сложность фазы 1.
Максимальный размер дерева <math>\frac{M}{P}</math>, где <math>P</math> - ограничение по памяти на размер узла, а <math>M</math> - общий объем памяти. Для того чтобы вставить элемент, мы должны пройти путь от корня до листа (это около <math>1+log_B\frac{M}{P}</math> узлов). В каждом узле в поисках "ближайшего" нам необходимо просмотреть B элементов; сложность для каждого элемента пропорциональна размерности ''d''.

Поэтому сложность вставки всех входных точек <math>O(d \cdot N \cdot B(1+log_B\frac{M}{P}))</math>.

В случае, когда необходимо перестроить дерево, предположим, что ES - это размер CF элемента. Существует максимум <math>\frac{M}{ES}</math> листьевых элементов для вставки, поэтому сложность повторной вставки листьевых элементов <math>O(d \cdot \frac{M}{ES} \cdot B(1+log_B\frac{M}{P}))</math>.

Количество итераций перестройки дерева зависит от пороговой величины. На самом деле, это около <math>log_2\frac{N}{N_0}</math> (двоичное основание появилось из-за того, что мы не можем провести оценку более чем в 2 раза отличающуюся от текущего размера). <math>N_0</math> - это число входных точек, загруженных в память с пороговым ограничением <math>T_0</math>.

Соответственно, итоговая сложность фазы 1 <math>O(d \cdot N \cdot B(1+log_B\frac{M}{P})+log_2\frac{N}{N_0} \cdot d \cdot \frac{M}{ES} \cdot B(1+log_B\frac{M}{P}))</math>.

Анализ фазы 2 проводится аналогично.

Что касается операций ввода-вывода, то в фазе 1 данные сканируются один раз, а в фазе 2 не сканируются вовсе.
Некоторое количество вычислений связано с удалением точек из областей с низкой плотностью.
Если количество доступной для этой операции памяти не больше ''M'' и проведено порядка <math>log_2\frac{N}{N_0}</math> перестроек дерева, то сложность ввода-вывода для фазы 1 существенно не отличается от сложности чтения из файла. Основываясь рассуждениях выше, сложность фаз 1 и 2 будет линейно увеличиваться с ростом N.

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

Фаза 4 снова сканирует данные и записывает каждую точку в подходящий кластер; время работы пропорционально <math>N \cdot K</math>.

<math></math>

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

=== Вычисление расстояния ===

<math>D_2=\frac{N_1\cdot SS_2+N_2\cdot SS_1-2 \cdot \vec{LS_1}\cdot \vec{LS_2}}{N_1\cdot N_2}</math>, где

<math>CF_1=[N_1,\vec{LS_1},SS_1]</math>

<math>CF_2=[N_2,\vec{LS_2},SS_2]</math>

[[File:ZgYL51QJsQk.jpg|600px|thumb|center]]

=== Поиск ближайшего подкластера ===

<math>E</math> - новый элемент

<math>CF_i, i = 1,...,B</math> - подкластеры узла

<math>m</math> - операция min

<math>\rho</math> - нахождение расстояния

[[File:PFA16KHUQ3I.jpg|600px|thumb|center]]

=== Скалярное произведение ===

<math>s = \vec{x}\cdot\vec{y}=\sum_{i=1}^d x_i\cdot y_i</math>

[[File:Xb7FYXVMPpQ.jpg|600px|thumb|center]]

<math></math>

== Ресурс параллелизма алгоритма ==
Параллельно могут быть выполнены следующие шаги алгоритма:
* Нахождение ближайшего к новому элементу подкластера в узле при выполнении операции вставки. Это возможно за счет того, что расстояние между парами элементов может быть вычислено независимо друг от друга.
* Вычисление величин <math>\vec{LS},\vec{X0}, R, D, D_0-D_4</math>, в процессе чего выполняются операции сложения и скалярного произведения векторов.

Таким образом, параллельная сложность фазы 1 алгоритма будет равна <math>O((N + log_2\frac{N}{N_0} \cdot \frac{M}{ES})(log_2 B + log_2 d)(1+log_B\frac{M}{P}))</math>

Другим способом параллелизации алгоритма может служить создание и заполнение сразу множества кластерных деревьев, между которыми будут распределены входные данные. Множество всех подкластеров листьевых узлов полученных таким образом деревьев может быть подвергнуто глобальной кластеризации с помощью какого-либо из известных параллельных алгоритмов, например, k-средних<ref>[A Garg, N Gupta PBIRCH: A Scalable Parallel Clustering algorithm for Incremental Data //10th International Database Engineering and Applications Symposium (IDEAS'06), 2006</ref>.

== Входные и выходные данные алгоритма ==
'''Входные данные:''' набор из <math>N</math> точек <math>\{X_i\}, i=1,...,N</math> размерности <math>d</math>.

'''Объем входных данных:''' <math>N \cdot d</math>

'''Выходные данные:''' кластерное дерево с не более чем <math>\frac{M}{P}</math> узлами.

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

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

Вычислительная мощность алгоритма имеет порядок <math>O(\frac{d \cdot B \cdot (1+log_B\frac{M}{P}) \cdot (N +log_2\frac{N}{N_0} \cdot \frac{M}{ES})}{N \cdot d + M})</math>

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

К достоинствам алгоритма можно отнести следующие его свойства:

1. BIRCH является локальным алгоритмом, то есть каждое решение о каждом элементе кластера принимается без повторного сканирования данных или уже существующих кластеров. Используются только метрики, отражающие близость элементов друг к другу.

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

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

4. BIRCH не требует всего набора данных заранее (при этом просматривает его всего один раз).

В свою очередь, недостатки алгоритма можно сформулировать следующим образом:

1. Алгоритм позволяет работать только с числовыми данными.

2. BIRCH хорошо выделяет только кластеры сферической формы.

3. Существует необходимость в задании пороговых значений.

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

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

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

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

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

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

[[file:Масштабируемость параллельной реализации алгоритма BIRCH. Производительность.png|thumb|center|700px|Рисунок 1. График времени работы параллельной реализации алгоритма BIRCH. ]]

[[file:Масштабируемость параллельной реализации алгоритма BIRCH. Эффективность.png|thumb|center|700px|Рисунок 2. График эффективности распараллеливания алгоритма BIRCH относительно последовательной реализации. ]]

Набор изменяемых параметров запуска реализации алгоритма и границы значений параметров алгоритма:
* число процессоров [8 : 80] с шагом 8
* число точек [100 000 : 1 000 000] с шагом 100 000

В результате проведённых экспериментов был получен следующий диапазон эффективности реализации алгоритма:
* минимальная эффективность реализации 9,13% (80 процессоров, 100 000 точек)
* максимальная эффективность реализации 235,42% (8 процессоров, 800 000 точек)

Полученные результаты могут быть объяснены недерминированностью алгоритма BIRCH и существенной зависимостью времени его работы от входных данных.

Оценка масштабируемости параллельной реализации:
* По числу процессов: при увеличении числа процессов эффективность распараллеливания снижается. При количестве процессов <math>n>30</math> темп снижения становится несущественным.
* По размеру задачи: при увеличении размера входных данных эффективность растет неравномерно, что свидетельствует о сложной зависимости от входных данных.

Для исследования возможностей паралеллизма алгоритма BIRCH была написана [https://github.com/duran-duran/birch реализация на языке C++] с использованием технологии MPI. В данной реализации входные данные равномерно распределяются между всеми процессами, в каждом из которых выполняется построение собственного кластерного дерева. Листьевые элементы полученных деревьев затем подвергаются глобальной кластеризации с помощью распределенного алгоритма k-средних. В качестве входных данных использовались точки размерности <math>d=5</math>, координаты которых были равномерно распределены в диапазоне <math>[-10000;10000]</math>.

{| class="wikitable mw-collapsible mw-collapsed"
! Технические детали реализации
|-
|
Компилятор: intel/15.0.090

Версия реализации MPI: openmpi/1.10.2-icc

Планировщик задач: slurm/2.5.6

Очереди: test, regular4

Команда компиляции: mpicxx -std=c++11 -Wall <source_files> -o <executable>

Команда запуска: sbatch -n <num_of_processes> -p <queue> -o <log_file> ompi <executable> <args>

|}

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

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

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

В составе пакетов и библиотек:
* [http://scikit-learn.org/stable/modules/generated/sklearn.cluster.Birch.html scikit-learn]
* [http://cucis.ece.northwestern.edu/projects/DMS/MineBench.html NU-MineBench]
Пользовательские реализации:
* [https://code.google.com/archive/p/jbirch/ JBIRCH]

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

Участник:Smirnov.maxim/BIRCH

2016-12-13T14:44:05Z

Coctic:

{{Assignment|{REVISIONUSER}}}}
Авторы: [[Участник:Светлана Морозова|Морозова Светлана]], [[Участник:Smirnov.maxim|Смирнов Максим]].
Вклад авторов:

Смирнов Максим:
*п.1.5
*п.1.7
*п.1.8
*п.1.9
*п.2.7

Морозова Светлана
*п.1.1
*п.1.2
*п.1.3
*п.1.4
*п.1.6
*п.1.10
*п.3

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

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

Нахождение полезных для анализа закономерностей в больших объёмах данных с недавних пор вызывает значительный интерес. В связи с этим ввелось и стало активно развиваться такое понятие как ''[https://ru.wikipedia.org/wiki/%D0%9A%D0%BB%D0%B0%D1%81%D1%82%D0%B5%D1%80%D0%BD%D1%8B%D0%B9_%D0%B0%D0%BD%D0%B0%D0%BB%D0%B8%D0%B7 кластеризация]''.

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

'''BIRCH'''<ref>Нейский И.М. Классификация и сравнение методов кластеризации // Интеллектуальные технологии и системы. Сборник учебно-методических работ и статей аспирантов и студентов. – М.: НОК «CLAIM», 2006. – Выпуск 8. – С. 130-142.</ref><ref>T Zhang, R Ramakrishnan, M Livny. BIRCH: An Efficient Data Clustering Method for Very Large Databases - 1996. - С.103-114)</ref> - алгоритм, применяемый в области [https://ru.wikipedia.org/wiki/Data_mining Data mining] и использующий принципы [https://ru.wikipedia.org/wiki/%D0%98%D0%B5%D1%80%D0%B0%D1%80%D1%85%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B0%D1%8F_%D0%BA%D0%BB%D0%B0%D1%81%D1%82%D0%B5%D1%80%D0%B8%D0%B7%D0%B0%D1%86%D0%B8%D1%8F иерархической кластеризации].

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

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

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

=== Теоретическая основа ===

Пусть в кластере имеются <math>N</math> точек размерности <math>d</math>: <math>\{\vec{X_i}\}, i=1,2,...,N</math>.
Тогда '''центроид''' <math>{\vec{{X_0}}}</math>, '''радиус''' <math>R</math> и '''диаметр''' <math>D</math> кластера определяются следующим образом:

<math>{\vec{X_0}}=\frac{\sum_{i=1}^N\vec{X_i}}{N}</math>

<math>R = (\frac{\sum_{i=1}^N{(\vec{X_i} - \vec{X_0})}^2}{N})^{1/2}</math>

<math>D = (\frac{\sum_{i=1}^N\sum_{j=1}^N{(\vec{X_i} - \vec{X_j})}^2}{N(N-1)})^{1/2}</math>

<math>R</math> - это среднее расстояние от каждой точки до центроида. <math>D</math> - это среднее расстояние между парами в кластере. Данные величины являются альтернативными метриками плотности кластера относительно центроида.

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

пусть даны центроиды двух кластеров <math>\vec{X_{01}}</math> и <math>\vec{X_{02}}</math>.
Евклидова метрика <math>D_0</math> и метрика Манхэттена <math>D1</math> между двумя кластерами определяются следующим образом:

<math>D_0 = ((\vec{X_{01}}-\vec{X_{02}})^2)^{1/2}</math>

<math>D_1 = |\vec{X_{01}}-\vec{X_{02}}| = \sum_{i=1}^d |{\vec{X_{01}}}^{(i)}-{\vec{X_{02}}}^{(i)}| </math>

Пусть имеются два кластера, содержащих соответственно <math>N_1</math> и <math>N_2</math> точек размерности <math>d</math>: <math>\{\vec{X_i}\}</math>, где <math>i= 1,2, ...,N_1</math> и <math>\{\vec{X_j}\}</math>, где <math>j= N_1+1,N_1+2, ...,N_1+N_2</math>.

'''Среднее расстояние''' <math>D_2</math>, '''среднее внутрикластерное расстояние''' <math>D_3</math> и '''дисперсия''' <math>D_4</math> для двух кластеров определяются следующим образом:

<math>D_2 = (\frac{\sum_{i=1}^{N_1}\sum_{j=N_1+1}^{N_1+N_2}{(\vec{X_i} - \vec{X_j})}^2}{N_1N_2})^{1/2}</math>

<math>D_3 = (\frac{\sum_{i=1}^{N_1+N_2}\sum_{j=1}^{N_1+N_2}{(\vec{X_i} - \vec{X_j})}^2}{(N_1+N_2)(N_1+N_2-1)})^{1/2}</math>

<math>D_4 = \sum_{k=1}^{N_1+N_2}(\vec{X_k} - \frac{\sum_{i=1}^{N_1+N_2}\vec{X_i}}{N_1+N_2})^2 - \sum_{i=1}^{N_1}(\vec{X_i} - \frac{\sum_{i=1}^{N_1}\vec{X_i}}{N_1})^2 - \sum_{j=N_1+1}^{N_1+N_2}(\vec{X_j} - \frac{\sum_{i=N_1+1}^{N_1+N_2}\vec{X_i}}{N_2})^2</math>

Таким образом, величины <math>\vec{X_0}</math>, <math>R</math> и <math>D</math> относятся к отдельным кластерам, а <math>D_0</math>, <math>D_1</math>, <math>D_2</math>, <math>D_3</math> и <math>D_4</math> - к объединению двух кластеров.

=== Кластерный элемент и кластерное дерево ===

В основе концепции алгоритма BIRCH лежат понятия '''кластерного элемента''' и '''кластерного дерева (CF Tree)'''.

====Кластерный элемент ====

''Определение.'' Пусть в кластере содержатся <math>N</math> точек размерности <math>d</math>:<math>\{\vec{X_i}\}</math>, где <math>i=1,2,...,N</math>.
'''Кластерный элемент (CF)''' - тройка чисел, характеризующая информацию о кластере:
<math>CF = (N, \vec{LS}, SS)</math>, где <math>N</math> - количество элементов входных данных, содержащихся в кластере, <math>\vec{LS}</math> - линейная сумма входных данных (т.е. <math>\sum_{i=1}^{N}\vec{X_i}</math>), <math>SS</math> - сумма квадратов входных данных (т.е. <math>\sum_{i=1}^{N}{\vec{X_i}}^2</math>)

'''Теорема''' Пусть <math>CF_1 = (N_1, \vec{LS_1}, SS_1)</math> и <math>CF_2 = (N_1, \vec{LS_2}, SS_2)</math> - CF векторы двух непересекающихся кластеров. Тогда при их объединении образуется кластер со следующим CF вектором:

<math>CF = CF_1 + CF_2 = (N_1+N_2, \vec{LS_1}+\vec{LS_2}, SS_1+SS_2)</math>.

Из указанных выше определения и теоремы вытекает тот факт, что при объединении кластеров их CF вектор может вычисляться инкрементно и точно.
Легко показать, что вычислить величины <math>\vec{X_0}</math>, <math>R</math>, <math>D</math>, <math>D_0</math>, <math>D_1</math>, <math>D_2</math>, <math>D_3</math>, <math>D_4</math>, как и обычные метрики, также не составит труда.

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

==== Кластерное дерево ====

''Определение.'' '''Кластерное дерево (CF Tree)''' - это взвешенно сбалансированное дерево с двумя параметрами: <math>B</math> - коэффициент разветвления, <math>T</math> - пороговая величина.

Каждый нелистьевой узел дерева имеет не более чем <math>B</math> вхождений узлов следующей формы: <math>[CF_i,child_i]</math>, где <math>i=1,2,...,B</math>, ''child'' - указатель на i-й дочерний узел, <math>CF_i</math> - CF вектор соответствующего подкластера.

Каждый листьевой узел имеет ссылку на два соседних узла (''prev'' и ''next'') для того, чтобы связать все узлы для эффективного сканирования.
Все листьевые узлы должны удовлетворять пороговому ограничению <math>T</math>, т.е. диаметр (радиус) не должен превосходить <math>T</math>.
В процессе вставки новых данных CF дерево строится динамически. Оно использует вставку данных для кластеризации точно также как <math>B+</math> [https://ru.wikipedia.org/wiki/B%2B-%D0%B4%D0%B5%D1%80%D0%B5%D0%B2%D0%BE дерево] использует её для поиска.
CF дерево очень компактно, поскольку каждый листьевой узел - это не просто точка, а подкластер (который объединяет множество точек с учётом ограничения <math>T</math>).

==== Операция вставки в '''CF''' дерево ====

Опишем алгоритм вставки элемнта <math>Ent</math> в CF дерево:

1) ''Определение подходящего листа'': Начиная с корня, алгоритм рекурсивно спускается по CF дереву, выбирая '''ближайший''' дочерний узел в соответствии с выбранной метрикой <math>D0</math>, <math>D1</math>, <math>D2</math>, <math>D3</math> или <math>D4</math>.

2) ''Преобразование листа'': Когда алгоритм доходит до листа, он находит ближайшую листьевой элемент, скажем, <math>L_1</math>, а затем проверяет, можно ли добавить ''Ent'' к <math>L_1</math> без нарушения порогового условия. Если да, то с учётом этого изменяется CF вектор для <math>L_1</math>; если нет, то ''Ent'' становится новым элементом листа. Если в листе для этого достаточно места, то шаг окончен, иначе он должен "расщепиться". Расщепление узла производится при помощи выбора за основу наиболее удалённой друг от друга пары элементов и перераспределение оставшихся элементов в соответствии с выбранным критерием близости.

3) ''Преобразование пути к листу'': После вставки ''Ent'' в лист мы должны обновить информацию о CF для каждого нелистьевого элемента на пути к листу. При отсутствии расщепления это означает простое сложение CF векторов для отражения факта добавления ''Ent''. Расщепление листа же требует вставки нового нелистьевого элемента в родительский узел для задания только что созданного листа. Если у родителя есть место для этого элемента, то необходимо просто преобразовать CF векторы на всех более высоких уровнях. В общем случае, однако, нам также придётся расщепить родительский узел, и так далее до корня. Если расщеплён корень, то высота дерева увеличивается на единицу.

4) ''Улучшение слияния'': Расщепление вызвано ограничением на размер узла, который не зависит от кластеризационных свойств данных. Если во входящем потоке присутствуют "искажённые" (из областей с низкой плотностью) данные, это может повлиять на качество кластеризации, а также уменьшить эффективность использования памяти. Дополнительный шаг алгоритма помогает решить эти проблемы: предположим, что произошло расщепление листа, и распространение этого процесса остановилось на некотором нелистьевом узле <math>N_j</math>, то есть <math>N_j</math> может вместить дополнительный элемент, полученный после расщепления. Теперь мы сканируем узел <math>N_j</math> для нахождения двух наиболее близких элементов. Если это не пара, отвечающая расщеплению, мы пытаемся объединить их и поставить в соответствие два дочерних узла. Если количество элементов в дочерних узлах больше B, мы снова расщепляем результат объединения.
В процессе повторного расщепления, в случае, если один источник собирает достаточно элементов для того, чтобы полностью заполнить узел, оставшиеся элементы передаются другом источнику. В итоге, если объединённые элементы помещаются в одном узле, в нём освобождается место для ещё одного элемента. Тем самым увеличивается степень использования свободного пространства и откладывается дальнейшее расщепление. В ином случае мы улучшаем распределение элементов в двух ближайших подкластерах.

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

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

* радиуса <math>R</math> или диаметра <math>D</math> кластерного элемента. Выполняется при попытке вставить новый элемент в один из подкластеров листьевого узла дерева.

* расстояния между двумя элементами. Выполняется при поиске ближайшего по отношению к новому элементу подкластера в узле дерева по одной из рассмотренных в разд. 1.2.1 метрик <math>D_0</math>, <math>D_1</math>, <math>D_2</math>, <math>D_3</math> или <math>D_4</math>.

Зная характеристики кластерных элементов <math>N</math>, <math>\vec{LS}</math> и <math>S</math>, в результате алгебраических преобразований можно получить следующие упрощенные формулы вычисления необходимых значений:

<math>\vec{X_0} = \frac{\vec{LS}}{N}</math>

<math>R = (\frac{SS - 2\vec{X_0}\vec{LS} + N(\vec{X_0})^2}{N})^{1/2}</math>

<math>D = (\frac{2(N \cdot SS - (\vec{LS})^2)}{N(N-1)})^{1/2}</math>

<math>D_2 = (\frac{N_1 \cdot SS_2 + N_2 \cdot SS_1 - 2\vec{LS_1}\vec{LS_2}}{N_1 \cdot N_2})^{1/2}</math>

<math>D_3 = (\frac{2((N_1+N_2)(SS_1+SS_2)-(\vec{LS_1}+\vec{LS_2})^2)}{(N_1+N_2)(N_1+N_2-1)})^{1/2}</math>

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

Реализация алгоритма BIRCH состояит из следующих четырёх фаз:

* '''Фаза 1'''. Главной задачей фазы 1 является сканирование всех данных и построение в памяти исходного CF дерева, используя заданное количество памяти. Это дерево стремится отразить информацию о кластеризации данных настолько хорошо, насколько это позволяют ограничения по памяти. При этом плотно распределённые данные группируются в подкластеры, а более разрозненные данные удаляются. После завершения фазы 1 вспомогательные вычисления в дальнейших фазах будут:

1) быстрее, потому что (а) больше не нужны операции ввода-вывода, (b) проблема кластеризации начальных данных упрощается до проблемы кластеризации подкластеров в листьях;

2) точнее, потому что (а) большинство данных с низкой плотностью удалены, (b) оставшиеся данные распределены оптимально (в соответствии с доступным количеством памяти);

* '''Фаза 2'''. Данная фаза является опциональной. Известно, что существующие методы глобальной кластеризации, используемые в рамках фазы 3, имеют различные диапазоны входных значений, при которых их реализация наиболее эффективна. Поэтому потенциально существует пробел между размером фазы 1 и входными значениями фазы 3. И фаза 2 как раз является недостающим связующим звеном: так же как и фаза 1, она сканирует листьевые элементы начального CF дерева для того, чтобы построить меньшее дерево, удаляя ещё больше элементов с низкой плотностью и группируя переполненные подкластеры в большие кластеры.

* '''Фаза 3'''. В данной фазе для листьевых элементов применяется (любой подходящий) алгоритм глобальной кластеризации. Существующие алгоритмы кластеризации наборов точек могут также работать с наборами подкластеров, каждый из которых представлен своим CF вектором. Зная CF вектор, можно вычислить центроид и в дальнейшем заменить всю информацию о кластере этим значением (этого достаточно для вычисления большинства необходимых метрик). После фазы 3 мы получаем набор кластеров, который отражает основные характеристики распределяемых данных.
Однако, всё ещё могут оставаться некоторые неточности, для устранения которых существует фаза 4.

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

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

<source lang="c++">
void CF_Node::insert(const CF_Cluster &entry)
{
//Находим ближайший к новому элементу подкластер в узле
СF_Vector_it closest = entry.findClosest(subclusters);
//Если узел пустой, добавляем в него новый подкластер
if (closest == subclusters.end()) {
subclusters.push_back(entry);
return;
}
closest->add(entry);
//Если узел является листьевым, и ближайший подкластер не может вместить
//новый элемент, добавляем в узел новый подкластер
if (leaf) {
if (closest->D > threshold) {
closest->remove(entry);
subclusters.push_back(entry);
}
}
else {
CF_Node *node = closest->child;
node->insert(entry);
//Если при добавлении нового элемента в дочерний узел тот переполнился,
//расщепляем его
if (node->getSubclusters().size() > bFactor) {
CF_Vector newClusters = node->splitNode();
delete node;
subclusters.erase(closest);
subclusters.insert(subclusters.end(), newClusters.begin(), newClusters.end());
}
}
//Если узел является корневым и он переполнен, расщепляем его
if (root && subclusters.size() > bFactor) {
subclusters = splitNode();
leaf = false;
}
}

CF_Vector CF_Node::splitNode()
{
if (subclusters.size() < 2)
return (root) ? subclusters : CF_Vector{CF_Cluster(this)};
//Находим пару наиболее удаленных друг от друга подкластеров
CF_Vector_it pole1, pole2;
data_t longestDist = 0.0;
for (auto lhs = subclusters.begin(); lhs != subclusters.end() - 1; ++lhs) {
for (auto rhs = lhs + 1; rhs != subclusters.end(); ++rhs) {
auto distance = getDistance(*lhs, *rhs);
if (distance > longestDist) {
longestDist = distance;
pole1 = lhs;
pole2 = rhs;
}
}
}
//Разделяем множество всех подкластеров узла на две части
CF_Vector subclusters1, subclusters2;
for (auto it = subclusters.begin(); it != subclusters.end(); ++it) {
if (getDistance(*it, *pole1) < getDistance(*it, *pole2))
subclusters1.push_back(*it);
else
subclusters2.push_back(*it);
}
//Создаем два новых узла
CF_Node *node1 = new CF_Node(threshold, bFactor, count, leaf, subclusters1),
*node2 = new CF_Node(threshold, bFactor, count, leaf, subclusters2);
//Связываем листья
if (leaf) {
if (prevLeaf) {
node1->setPrevLeaf(prevLeaf);
prevLeaf->setNextLeaf(node1);
}
if (nextLeaf) {
node2->setNextLeaf(nextLeaf);
nextLeaf->setPrevLeaf(node2);
}
node1->setNextLeaf(node2);
node2->setPrevLeaf(node1);
}
CF_Cluster cluster1(node1), cluster2(node2);
return CF_Vector{cluster1, cluster2};
}
</source>

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

Для начала проанализируем вычислительную сложность фазы 1.
Максимальный размер дерева <math>\frac{M}{P}</math>, где <math>P</math> - ограничение по памяти на размер узла, а <math>M</math> - общий объем памяти. Для того чтобы вставить элемент, мы должны пройти путь от корня до листа (это около <math>1+log_B\frac{M}{P}</math> узлов). В каждом узле в поисках "ближайшего" нам необходимо просмотреть B элементов; сложность для каждого элемента пропорциональна размерности ''d''.

Поэтому сложность вставки всех входных точек <math>O(d \cdot N \cdot B(1+log_B\frac{M}{P}))</math>.

В случае, когда необходимо перестроить дерево, предположим, что ES - это размер CF элемента. Существует максимум <math>\frac{M}{ES}</math> листьевых элементов для вставки, поэтому сложность повторной вставки листьевых элементов <math>O(d \cdot \frac{M}{ES} \cdot B(1+log_B\frac{M}{P}))</math>.

Количество итераций перестройки дерева зависит от пороговой величины. На самом деле, это около <math>log_2\frac{N}{N_0}</math> (двоичное основание появилось из-за того, что мы не можем провести оценку более чем в 2 раза отличающуюся от текущего размера). <math>N_0</math> - это число входных точек, загруженных в память с пороговым ограничением <math>T_0</math>.

Соответственно, итоговая сложность фазы 1 <math>O(d \cdot N \cdot B(1+log_B\frac{M}{P})+log_2\frac{N}{N_0} \cdot d \cdot \frac{M}{ES} \cdot B(1+log_B\frac{M}{P}))</math>.

Анализ фазы 2 проводится аналогично.

Что касается операций ввода-вывода, то в фазе 1 данные сканируются один раз, а в фазе 2 не сканируются вовсе.
Некоторое количество вычислений связано с удалением точек из областей с низкой плотностью.
Если количество доступной для этой операции памяти не больше ''M'' и проведено порядка <math>log_2\frac{N}{N_0}</math> перестроек дерева, то сложность ввода-вывода для фазы 1 существенно не отличается от сложности чтения из файла. Основываясь рассуждениях выше, сложность фаз 1 и 2 будет линейно увеличиваться с ростом N.

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

Фаза 4 снова сканирует данные и записывает каждую точку в подходящий кластер; время работы пропорционально <math>N \cdot K</math>.

<math></math>

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

=== Вычисление расстояния ===

<math>D_2=\frac{N_1\cdot SS_2+N_2\cdot SS_1-2 \cdot \vec{LS_1}\cdot \vec{LS_2}}{N_1\cdot N_2}</math>, где

<math>CF_1=[N_1,\vec{LS_1},SS_1]</math>

<math>CF_2=[N_2,\vec{LS_2},SS_2]</math>

[[File:ZgYL51QJsQk.jpg|600px|thumb|center]]

=== Поиск ближайшего подкластера ===

<math>E</math> - новый элемент

<math>CF_i, i = 1,...,B</math> - подкластеры узла

<math>m</math> - операция min

<math>\rho</math> - нахождение расстояния

[[File:PFA16KHUQ3I.jpg|600px|thumb|center]]

=== Скалярное произведение ===

<math>s = \vec{x}\cdot\vec{y}=\sum_{i=1}^d x_i\cdot y_i</math>

[[File:Xb7FYXVMPpQ.jpg|600px|thumb|center]]

<math></math>

== Ресурс параллелизма алгоритма ==
Параллельно могут быть выполнены следующие шаги алгоритма:
* Нахождение ближайшего к новому элементу подкластера в узле при выполнении операции вставки. Это возможно за счет того, что расстояние между парами элементов может быть вычислено независимо друг от друга.
* Вычисление величин <math>\vec{LS},\vec{X0}, R, D, D_0-D_4</math>, в процессе чего выполняются операции сложения и скалярного произведения векторов.

Таким образом, параллельная сложность фазы 1 алгоритма будет равна <math>O((N + log_2\frac{N}{N_0} \cdot \frac{M}{ES})(log_2 B + log_2 d)(1+log_B\frac{M}{P}))</math>

Другим способом параллелизации алгоритма может служить создание и заполнение сразу множества кластерных деревьев, между которыми будут распределены входные данные. Множество всех подкластеров листьевых узлов полученных таким образом деревьев может быть подвергнуто глобальной кластеризации с помощью какого-либо из известных параллельных алгоритмов, например, k-средних<ref>[A Garg, N Gupta PBIRCH: A Scalable Parallel Clustering algorithm for Incremental Data //10th International Database Engineering and Applications Symposium (IDEAS'06), 2006</ref>.

== Входные и выходные данные алгоритма ==
'''Входные данные:''' набор из <math>N</math> точек <math>\{X_i\}, i=1,...,N</math> размерности <math>d</math>.

'''Объем входных данных:''' <math>N \cdot d</math>

'''Выходные данные:''' кластерное дерево с не более чем <math>\frac{M}{P}</math> узлами.

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

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

Вычислительная мощность алгоритма имеет порядок <math>O(\frac{d \cdot B \cdot (1+log_B\frac{M}{P}) \cdot (N +log_2\frac{N}{N_0} \cdot \frac{M}{ES})}{N \cdot d + M})</math>

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

К достоинствам алгоритма можно отнести следующие его свойства:

1. BIRCH является локальным алгоритмом, то есть каждое решение о каждом элементе кластера принимается без повторного сканирования данных или уже существующих кластеров. Используются только метрики, отражающие близость элементов друг к другу.

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

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

4. BIRCH не требует всего набора данных заранее (при этом просматривает его всего один раз).

В свою очередь, недостатки алгоритма можно сформулировать следующим образом:

1. Алгоритм позволяет работать только с числовыми данными.

2. BIRCH хорошо выделяет только кластеры сферической формы.

3. Существует необходимость в задании пороговых значений.

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

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

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

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

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

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

[[file:Масштабируемость параллельной реализации алгоритма BIRCH. Производительность.png|thumb|center|700px|Рисунок 1. График времени работы параллельной реализации алгоритма BIRCH. ]]

[[file:Масштабируемость параллельной реализации алгоритма BIRCH. Эффективность.png|thumb|center|700px|Рисунок 2. График эффективности распараллеливания алгоритма BIRCH относительно последовательной реализации. ]]

Набор изменяемых параметров запуска реализации алгоритма и границы значений параметров алгоритма:
* число процессоров [8 : 80] с шагом 8
* число точек [100 000 : 1 000 000] с шагом 100 000

В результате проведённых экспериментов был получен следующий диапазон эффективности реализации алгоритма:
* минимальная эффективность реализации 9,13% (80 процессоров, 100 000 точек)
* максимальная эффективность реализации 235,42% (8 процессоров, 800 000 точек)

Полученные результаты могут быть объяснены недерминированностью алгоритма BIRCH и существенной зависимостью времени его работы от входных данных.

Оценка масштабируемости параллельной реализации:
* По числу процессов: при увеличении числа процессов эффективность распараллеливания снижается. При количестве процессов <math>n>30</math> темп снижения становится несущественным.
* По размеру задачи: при увеличении размера входных данных эффективность растет неравномерно, что свидетельствует о сложной зависимости от входных данных.

Для исследования возможностей паралеллизма алгоритма BIRCH была написана [https://github.com/duran-duran/birch реализация на языке C++] с использованием технологии MPI. В данной реализации входные данные равномерно распределяются между всеми процессами, в каждом из которых выполняется построение собственного кластерного дерева. Листьевые элементы полученных деревьев затем подвергаются глобальной кластеризации с помощью распределенного алгоритма k-средних. В качестве входных данных использовались точки размерности <math>d=5</math>, координаты которых были равномерно распределены в диапазоне <math>[-10000;10000]</math>.

{| class="wikitable mw-collapsible mw-collapsed"
! Технические детали реализации
|-
|
Компилятор: intel/15.0.090

Версия реализации MPI: openmpi/1.10.2-icc

Планировщик задач: slurm/2.5.6

Очереди: test, regular4

Команда компиляции: mpicxx -std=c++11 -Wall <source_files> -o <executable>

Команда запуска: sbatch -n <num_of_processes> -p <queue> -o <log_file> ompi <executable> <args>

|}

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

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

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

В составе пакетов и библиотек:
* [http://scikit-learn.org/stable/modules/generated/sklearn.cluster.Birch.html scikit-learn]
* [http://cucis.ece.northwestern.edu/projects/DMS/MineBench.html NU-MineBench]
Пользовательские реализации:
* [https://code.google.com/archive/p/jbirch/ JBIRCH]

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

Обсуждение участника:Светлана Морозова

2016-12-13T14:43:45Z

Coctic:

== Статья [[Участник:Smirnov.maxim/BIRCH]] ==

=== Неправильная структура статьи ===
* Слово "Часть" в заголовках лишнее [[Участник:Coctic|Coctic]] ([[Обсуждение участника:Coctic|обсуждение]]) 17:55, 21 октября 2016 (MSK)
** Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 15:01, 31 октября 2016 (MSK)
* Название пункта 1.3 не из шаблона [[Участник:Coctic|Coctic]] ([[Обсуждение участника:Coctic|обсуждение]]) 17:55, 21 октября 2016 (MSK)
** Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 15:01, 31 октября 2016 (MSK)
* Пункты 1.4-1.5 должны быть 1.3-1.4 [[Участник:Coctic|Coctic]] ([[Обсуждение участника:Coctic|обсуждение]]) 17:55, 21 октября 2016 (MSK)
** Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 15:01, 31 октября 2016 (MSK)
* Пункты 3.1 шаблоном не предусмотрен [[Участник:Coctic|Coctic]] ([[Обсуждение участника:Coctic|обсуждение]]) 17:55, 21 октября 2016 (MSK)
** Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 15:01, 31 октября 2016 (MSK)

=== Отсутствующие части ===
* Отсутствует указание автора [[Участник:Coctic|Coctic]] ([[Обсуждение участника:Coctic|обсуждение]]) 17:55, 21 октября 2016 (MSK)
** Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 15:01, 31 октября 2016 (MSK)
* Нет пунктов 1.5-1.10, 2.7 [[Участник:Coctic|Coctic]] ([[Обсуждение участника:Coctic|обсуждение]]) 17:55, 21 октября 2016 (MSK)
** Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 15:01, 31 октября 2016 (MSK)
* В тексте есть ссылки на 2 рисунка, которых нет [[Участник:Coctic|Coctic]] ([[Обсуждение участника:Coctic|обсуждение]]) 17:55, 21 октября 2016 (MSK)
** Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 15:01, 31 октября 2016 (MSK)

=== Замечания по тексту ===
* Пункт 1.3: есть указание на "фазу 1", нет описания дальнейших фаз [[Участник:Coctic|Coctic]] ([[Обсуждение участника:Coctic|обсуждение]]) 17:55, 21 октября 2016 (MSK)
** Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 15:01, 31 октября 2016 (MSK)
* Пункт 1.3: названия подпунктов "фаза 1", "уменьшаемость", "пороговые значения", "достоинства алгоритма" не выглядят логическими частями описания алгоритма [[Участник:Coctic|Coctic]] ([[Обсуждение участника:Coctic|обсуждение]]) 17:55, 21 октября 2016 (MSK)
** Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 15:01, 31 октября 2016 (MSK)
* В разделе "Литература" единственная ссылка на Википедию, причем на на конкретную страницу, а на Википедию вообще (причем ссылка не ведет никуда, это просто текст). Фактически список литературы отсутствует. [[Участник:Coctic|Coctic]] ([[Обсуждение участника:Coctic|обсуждение]]) 17:55, 21 октября 2016 (MSK)
** Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 15:01, 31 октября 2016 (MSK)
--------------------------
* в списке авторов не указан вклад каждого автора [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 15:01, 31 октября 2016 (MSK)
** Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 10:51, 7 ноября 2016 (MSK)
* п. 1.8 не приведена оценка параллельной сложности алгоритма [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 15:01, 31 октября 2016 (MSK)
** Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 10:51, 7 ноября 2016 (MSK)
* п. 1.9 не приведены оценки объема входных и выходных данных [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 15:01, 31 октября 2016 (MSK)
** Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 10:51, 7 ноября 2016 (MSK)
* п. 1.10 не приведена оценка вычислительной мощности алгоритма [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 15:01, 31 октября 2016 (MSK)
** Не исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 10:51, 7 ноября 2016 (MSK)
** Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 16:51, 16 ноября 2016 (MSK)
* в списке литературы у ссылок отсутствуют выходные данные, позволяющие их однозначно идентифицировать [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 15:01, 31 октября 2016 (MSK)
** Исправлено частично. Ссылка 1 по-прежнему не имеет достаточного количества выходных данных [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 10:51, 7 ноября 2016 (MSK)
** Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 16:51, 16 ноября 2016 (MSK)
* Отсутствует п. 2.4. [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 16:51, 16 ноября 2016 (MSK)
** Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 12:57, 12 декабря 2016 (MSK)
* Необходимо указать характеристики программно-аппаратной платформы (какой компилятор, с какими опциями использовался, какие версии библиотек, на каких узлах проводился запуск и т.д.) [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 12:57, 12 декабря 2016 (MSK)
** Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 17:43, 13 декабря 2016 (MSK)

Участник:Шишков Илья Сергеевич/Алгоритм HCM (Hard C – Means)

2016-12-13T14:42:33Z

Coctic:

{{algorithm
| name = Алгоритм HCM (Hard C – Means)
| serial_complexity = <math>O(ncK)</math>
| pf_height = <math>O(1)</math>
| pf_width = <math>O(cK)</math>
| input_data = <math>O(nK)</math>
| output_data = <math>O(c(K+n))</math>
}}

Основные авторы описания: [[Участник:Шишков_Илья_Сергеевич|Илья Шишков]] (1.1-1.4, 2.7), [[Участник:Темербекова_Гульгайша|Гульгайша Темербекова]] (1.5-1.10, 3)

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

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

Алгоритм HCM (Строгий алгоритм С-средних) был предложен группой исследователей(Jang, Sun and Mizutani) в 1997 и относится к классу алгоритмов со строгой кластеризаций.

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

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

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

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

Алгоритм HCM является итеративным и состоит из нескольких шагов:

1.'''Инициализация: '''

Случайным образом определяются C векторов - центров кластеров

2. '''Расчет рядовой матрицы:'''

В процессе расчета рядовой матрицы каждый вектор сравнивается с ближайшим кластерным центром

3. '''Расчет оценочной функции:'''

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

4. '''Переопределение кластерных центров'''

Пункты 2-4 выполняются до тех пор, пока в пункте 3 проверка не станет успешной.

=== Математическое описание алгоритма <ref>Arabinda Panda & Satchidananda Dehuri. Hard C-means Clustering Algorithm in Gene Expression Data // International Journal on Advanced Computer Theory and Engineering, ISSN-PRINT: 2319-2526. - 2013. - v. 2. - p. 35-39 [http://www.irdindia.in/journal_ijacte/pdf/vol2_iss1/8.pdf]</ref> ===

Обозначения

<math>U</math> - наборы данных

<math>u_{i}</math> - i-ый набор из <math>U</math>

<math>u</math> - любой набор из <math>U</math>

<math>K</math> - количество наборов в <math>U</math>

<math>c_{j}</math> - j-ый кластер

<math>c</math> - количество кластеров

<math>c_{j}</math> - j-ый кластерный центр

<math>c^*_{j}</math> - j-ый кластерный центр после обновления

Выходные данные:
<math>c^*_{1}, c^*_{2}, ... c^*_{c}, M</math>

Объектная функция:

<math>J=\sum_{j = 1}^{c} \sum_{u_{i} \in C_{j}}^{} \|u_{i}-c_{j}\|^2, j \in 1,2, ... c, i={1,2, ...K}</math>

'''Шаг 1'''

Из входного набора <math>u_{1},u_{2}, ... u_{n}</math> выбираются <math>c</math> начальных кластерных центра <math> c_{1},c_{2},...,c_{c}</math>либо случайным образом, либо с использованием заранее определенного алгоритма

'''Шаг 2'''

Рассчитывается рядовая матрица <math> M=\|m_{ik}\|</math> каждый элемент которой вычисляется по следующей формуле:
:<math>
m_{ik} = \begin{cases}
1, & \|u_k-c_i\|^2 \leqslant \|u_k-c_j\|^2 \;\; \text{for all } i \neq j; \;\; (i,j=1,2,\ldots,c; \; k = 1,2,\ldots,K)\\
0, & \text{other}.
\end{cases}
</math>

'''Шаг 3'''

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

'''Шаг 4'''

Рассчитываются новые кластерные центры по следующей формуле:

<math> c^*_{j} = \frac{1}{|C_{j}|} \sum_{u_{i} \in C_{j}}^{} c_{i}, j=1,2,3..,c</math>

где <math>|C_{j}| </math> - число элементов, принадлежащих кластеру <math>C_{j}</math>

'''Шаг 5'''

Если алгоритм не завершил свою работу на шаге 3 то переходим к шагу 2.

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

Вычислительным ядром данного алгоритма является вычисление на каждой итерации алгоритма квадратов норм между кластерными центрами и векторами из входного набор согласно формуле <math>\|u_k-c_i\|^2</math>. На каждой итерации алгоритма происходит <math>cK</math> таких вычислений.

=== Макроструктура алгоритма ===
Основной операцией алгоритма является операция нахождения квадратов расстояний между исходными векторами и кластерными центрами.

<math>
\|u_k-c_i\|^2
</math>

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

<math>J=\sum_{j = 1}^{c} \sum_{u_{i} \in C_{j}}^{} \|u_{i}-c_{j}\|^2, j \in 1,2, ... c, i={1,2, ...K}</math>

При перерасчете кластерных центров происходит суммирование векторов:

<math> c^*_{j} = \frac{1}{|C_{j}|} \sum_{u_{i} \in C_{j}}^{} u_{i}, j=1,2,3..,c</math>

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

Последовательность исполнения метода следующая <ref> Jyh-Shing Roger Jang, Chuen-Tsai Sun, Eiji Mizutani. Neuro-fuzzy and soft computing: a computational approach to learning and machine intelligence. Prentice-Hall, Inc. Simon & Schuster/A Viacom Company Upper Saddle River, NJ 07458. - 1997. - p. 424. [http://it-claim.ru/Persons/Neyskiy/Article2_Neiskiy.pdf]</ref>:

1. Инициализация кластерных центров <math>c_i \, (i=1,2,\ldots,c)</math>. Это можно сделать выбрав случайным образом <math>c</math> – векторов из входного набора.

2. Вычисление рядовой матрицы <math>M</math>:
:<math>
m_{ik} = \begin{cases}
1, & \|u_k-c_i\|^2 \leqslant \|u_k-c_j\|^2 \;\; \text{for all } i \neq j; \;\; (i,j=1,2,\ldots,c; \; k = 1,2,\ldots,K) \\
0, & \text{other}.
\end{cases}
</math>
где К – количество элементов во входном наборе данных.

Матрица <math>M</math> обладает следующими свойствами:
:<math>
\sum\limits_{i=1}^c m_{ij} = 1, \;\; \sum\limits_{j=1}^K m_{ij} = K.
</math>

3. Расчёт объектной функции:
:<math>
J = \sum\limits_{i=1}^c J_i = \sum\limits_{i=1}^c \left( \sum\limits_{k:\, u_k \in C_i} \|u_k -c_i \|^2 \right)
.</math>

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

4. Пересчёт кластерных центров выполняется в соответствии со следующим уравнением:
:<math>
c_i = \frac{1}{|C_i|} \sum\limits_{k:\, u_k \in C_i} u_k,
</math>
где под <math>|C_i|</math> подразумевается количество элементов в <math>i</math>-ом кластере.

5. на шаг 2.

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

Для каждой итерации алгоритма требуется:
* <math>ncK</math> умножений,
* <math>ncK</math> вычитаний,
* <math>K(cn+1)</math> сложений,
* <math>K(c-1)</math> сравнений.

Умножения, сложения (вычитания), сравнения составляют ''основную часть алгоритма''.

Итоговая сложность последовательной реализации алгоритма <math>O(ncK)</math> <ref> Pawan Kumar, Mr. Pankaj Verma, Rakesh Sharma. Comparative analysis of Fuzzy C-mean and Hard C-mean algorithm // International Journal of information Technology and Knowledge Management. - July-December 2010. - v. 2 [http://csjournals.com/IJITKM/PDF%203-1/39.pdf]</ref>. Обычно <math>n</math>, <math>c</math> значительно меньше, чем <math>K</math>.

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

Граф алгоритма состоит из пяти групп вершин.

'''Первая''' группа вершин '''''<math>c_1,...,c_c</math>''''' - прямое вычисление расстояния до кластерных центров, то есть вычисление расстояний от заданного элемента <math>u_i</math> до каждого из кластерных центров.

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

'''Третья''' группа вершин '''''M''''' - ей соответствует операция записи единички в столбец матрицы.

'''Четвертая''' группа вершин '''''J''''' - вычисление объектной функции, происходит проверка условия достижения необходимой точности, если достигли заданной точности то переход в '''''Out''''', в противном случае '''''Conversion'''''.

'''Пятая''' группа вершин '''''Conversion''''' - пересчёт кластерных центров и переход на следующую итерацию.

На рисунке изображена одна итерация алгоритма.

[[File:Picture.png|thumb|600px|center|Рисунок 1. '''''in''''' - входные данные, '''''<math>c_1,...,c_c</math>''''' - вычисление расстояния до кластерных центров и значение <math>u_i</math> единое для каждой группы '''''<math>c_1,...,c_c</math>''''', '''''min''''' - нахождение минимального расстояния до кластерных центров, '''''M''''' - запись единички в столбец матрицы, '''''J''''' - расчёт объектной функции, '''''Conversion''''' — пересчёт кластерных центров, '''''out''''' — вывод полученных данных.]]

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

Для одной итерации алгоритма в параллельном варианте требуется <math>K</math> раз последовательно выполнить для каждого <math>u_i</math> следующие ярусы:
* <math>C</math> операций нахождения расстояния от элемента <math>u_i</math> до каждого из кластерных центров.
* <math>C-1</math> сравнений, для нахождения минимального расстояния.
* операция записи единички в столбец матрицы <math>M</math>.

Основным ресурсом алгоритма является вычисление квадрата нормы для каждого <math>u_i</math>. Расчёт значения объектной функции <math>J</math> сложно представить в параллельном варианте, поэтому вычисление объектной функции производится последовательно.Использование параллельной реализации алгоритма приведёт к понижению производительности при небольшой размерности системы и малом объеме выборки. При параллельном варианте необходима пересылка данных, что при малом объеме выборки и небольшой размерности займет больше времени, чем при последовательном варианте.
Как легко видеть из информационного графа, высота [[глоссарий#Ярусно-параллельная форма графа алгоритма|ЯПФ]] составляет <math>O(1)</math>, ширина ЯПФ составляет <math>O(cK)</math>, если число итераций меньше объема выборки.

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

'''Входные данные:'''
# <math>\{u_k\}_{k=1}^{K}</math> — исходный набор векторов, принадлежащие пространству <math>\mathbb{R}^n</math>;
# <math>c</math> — количество кластеров;

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

'''Выходные данные:'''
# <math>M</math> — матрица, принадлежащая пространству <math>\mathbb{R}^{c \times K}</math>.
# <math>\{c^*_i\}_{i=1}^{c}</math> — набор построенных кластерных центров.

'''Объём выходных данных:''' <math>c(K+n)</math>.

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

'''Назначение:''' кластеризация больших наборов числовых данных.

'''Достоинства:''' легкость реализации,вычислительная простота.

'''Недостатки:''' задание количества кластеров,отсутствие гарантии в нахождении оптимального решения.

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
==== Локальность реализации алгоритма ====
===== Структура обращений в память и качественная оценка локальности =====
===== Количественная оценка локальности =====
=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===
==== Масштабируемость алгоритма ====
==== Масштабируемость реализации алгоритма ====
Проведём исследование масштабируемости параллельной реализации алгоритма Hard C - Means (HCM). Исследование проводилось на суперкомпьютере "Ломоносов" [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета] с пиковой производительностью 1,7 Пфлопс, число процессоров/ядер x86: 12 346 / 52 168. Программа написана на языке C с использованием [http://hpc.cmc.msu.ru/bgp/development/parallel MPI], не использовалось дополнительных опций. Использовалась следующая [https://github.com/cNikolaou/mpi-kmeans параллельная реализация алгоритма HCM].

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

* число ядер <math>[16 : 256]</math> с шагом по степеням двойки;
* объём выборки <math>[10^3:10^7]</math> с шагом по степеням десятки;

На следующем рисунке приведен график [[Глоссарий#Производительность|производительности]] выбранной реализации алгоритма Hard C - Means (HCM).
[[Файл:scheme1.png]]

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

* [https://github.com/artpar/Hard-Clustering-implementation Последовательная реализация на С++ ]

* [http://projects.jasmeet.me/2013/03/HardCMeans.html Последовательная реализация на MatLab ]

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

Обсуждение участника:Шишков Илья Сергеевич

2016-12-13T14:42:11Z

Coctic:

= Статья [[Алгоритм HCM (Hard C – Means)]] =
* Не указан вклад каждого автора [[Участник:Coctic|Coctic]] ([[Обсуждение участника:Coctic|обсуждение]]) 10:47, 25 октября 2016 (MSK)
** Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 11:06, 1 ноября 2016 (MSK)
* п. 1.1 Стоит добавит ссылку на публикацию, в которой алгоритм был впервые описан (Jang, Sun and Mizutani) [[Участник:Coctic|Coctic]] ([[Обсуждение участника:Coctic|обсуждение]]) 10:47, 25 октября 2016 (MSK)
* Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 11:06, 1 ноября 2016 (MSK)
* п. 1.3 Сказано, что "На каждой итерации алгоритма происходит <math>CN</math> таких вычислений", однако определений C и N не приведено ни здесь, ни ранее. Ранее имеется определение для c (c малого), но это другой символ. [[Участник:Coctic|Coctic]] ([[Обсуждение участника:Coctic|обсуждение]]) 10:47, 25 октября 2016 (MSK)
** Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 11:06, 1 ноября 2016 (MSK)
* Ссылки в списке литературы не содержат данных публикации, кроме названия и списка авторов. Веб-ссылки на какую-то версию публикации недостаточно. [[Участник:Coctic|Coctic]] ([[Обсуждение участника:Coctic|обсуждение]]) 10:52, 25 октября 2016 (MSK)
** Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 11:06, 1 ноября 2016 (MSK)
** Замечания были приняты и исправлены огрехи. [[Участник:Темербекова_Гульгайша|Темербекова_Гульгайша]] ([[Обсуждение участника:Темербекова_Гульгайша|обсуждение]]) 23:40, 31 октября 2016 (MSK)

* Отсутствует п. 2.4. [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 16:54, 16 ноября 2016 (MSK)
** Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 17:42, 13 декабря 2016 (MSK)
* Необходимо указать характеристики программно-аппаратной платформы (какой компилятор, с какими опциями использовался, какие версии библиотек, на каких узлах проводился запуск и т.д.). Указано, что запуск осуществлялся на Ломоносове, ссылка на MPI приведена на страницы, описывающие BlueGene/P, понять, какая реализация MPI использовалась, невозможно [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 17:42, 13 декабря 2016 (MSK)
* На неподписанном рисунке в п. 2.4. в подписи к оси аппликат указано, что по ней отложено время в секундах, в абзаце перед рисунком указано, что приведен график производительности. Что из этого верно, неясно. [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 17:42, 13 декабря 2016 (MSK)

Участник:Smirnov.maxim/BIRCH

2016-12-12T09:57:13Z

Coctic:

Авторы: [[Участник:Светлана Морозова|Морозова Светлана]], [[Участник:Smirnov.maxim|Смирнов Максим]].
Вклад авторов:

Смирнов Максим:
*п.1.5
*п.1.7
*п.1.8
*п.1.9
*п.2.7

Морозова Светлана
*п.1.1
*п.1.2
*п.1.3
*п.1.4
*п.1.6
*п.1.10
*п.3

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

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

Нахождение полезных для анализа закономерностей в больших объёмах данных с недавних пор вызывает значительный интерес. В связи с этим ввелось и стало активно развиваться такое понятие как ''[https://ru.wikipedia.org/wiki/%D0%9A%D0%BB%D0%B0%D1%81%D1%82%D0%B5%D1%80%D0%BD%D1%8B%D0%B9_%D0%B0%D0%BD%D0%B0%D0%BB%D0%B8%D0%B7 кластеризация]''.

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

'''BIRCH'''<ref>Нейский И.М. Классификация и сравнение методов кластеризации // Интеллектуальные технологии и системы. Сборник учебно-методических работ и статей аспирантов и студентов. – М.: НОК «CLAIM», 2006. – Выпуск 8. – С. 130-142.</ref><ref>T Zhang, R Ramakrishnan, M Livny. BIRCH: An Efficient Data Clustering Method for Very Large Databases - 1996. - С.103-114)</ref> - алгоритм, применяемый в области [https://ru.wikipedia.org/wiki/Data_mining Data mining] и использующий принципы [https://ru.wikipedia.org/wiki/%D0%98%D0%B5%D1%80%D0%B0%D1%80%D1%85%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B0%D1%8F_%D0%BA%D0%BB%D0%B0%D1%81%D1%82%D0%B5%D1%80%D0%B8%D0%B7%D0%B0%D1%86%D0%B8%D1%8F иерархической кластеризации].

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

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

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

=== Теоретическая основа ===

Пусть в кластере имеются <math>N</math> точек размерности <math>d</math>: <math>\{\vec{X_i}\}, i=1,2,...,N</math>.
Тогда '''центроид''' <math>{\vec{{X_0}}}</math>, '''радиус''' <math>R</math> и '''диаметр''' <math>D</math> кластера определяются следующим образом:

<math>{\vec{X_0}}=\frac{\sum_{i=1}^N\vec{X_i}}{N}</math>

<math>R = (\frac{\sum_{i=1}^N{(\vec{X_i} - \vec{X_0})}^2}{N})^{1/2}</math>

<math>D = (\frac{\sum_{i=1}^N\sum_{j=1}^N{(\vec{X_i} - \vec{X_j})}^2}{N(N-1)})^{1/2}</math>

<math>R</math> - это среднее расстояние от каждой точки до центроида. <math>D</math> - это среднее расстояние между парами в кластере. Данные величины являются альтернативными метриками плотности кластера относительно центроида.

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

пусть даны центроиды двух кластеров <math>\vec{X_{01}}</math> и <math>\vec{X_{02}}</math>.
Евклидова метрика <math>D_0</math> и метрика Манхэттена <math>D1</math> между двумя кластерами определяются следующим образом:

<math>D_0 = ((\vec{X_{01}}-\vec{X_{02}})^2)^{1/2}</math>

<math>D_1 = |\vec{X_{01}}-\vec{X_{02}}| = \sum_{i=1}^d |{\vec{X_{01}}}^{(i)}-{\vec{X_{02}}}^{(i)}| </math>

Пусть имеются два кластера, содержащих соответственно <math>N_1</math> и <math>N_2</math> точек размерности <math>d</math>: <math>\{\vec{X_i}\}</math>, где <math>i= 1,2, ...,N_1</math> и <math>\{\vec{X_j}\}</math>, где <math>j= N_1+1,N_1+2, ...,N_1+N_2</math>.

'''Среднее расстояние''' <math>D_2</math>, '''среднее внутрикластерное расстояние''' <math>D_3</math> и '''дисперсия''' <math>D_4</math> для двух кластеров определяются следующим образом:

<math>D_2 = (\frac{\sum_{i=1}^{N_1}\sum_{j=N_1+1}^{N_1+N_2}{(\vec{X_i} - \vec{X_j})}^2}{N_1N_2})^{1/2}</math>

<math>D_3 = (\frac{\sum_{i=1}^{N_1+N_2}\sum_{j=1}^{N_1+N_2}{(\vec{X_i} - \vec{X_j})}^2}{(N_1+N_2)(N_1+N_2-1)})^{1/2}</math>

<math>D_4 = \sum_{k=1}^{N_1+N_2}(\vec{X_k} - \frac{\sum_{i=1}^{N_1+N_2}\vec{X_i}}{N_1+N_2})^2 - \sum_{i=1}^{N_1}(\vec{X_i} - \frac{\sum_{i=1}^{N_1}\vec{X_i}}{N_1})^2 - \sum_{j=N_1+1}^{N_1+N_2}(\vec{X_j} - \frac{\sum_{i=N_1+1}^{N_1+N_2}\vec{X_i}}{N_2})^2</math>

Таким образом, величины <math>\vec{X_0}</math>, <math>R</math> и <math>D</math> относятся к отдельным кластерам, а <math>D_0</math>, <math>D_1</math>, <math>D_2</math>, <math>D_3</math> и <math>D_4</math> - к объединению двух кластеров.

=== Кластерный элемент и кластерное дерево ===

В основе концепции алгоритма BIRCH лежат понятия '''кластерного элемента''' и '''кластерного дерева (CF Tree)'''.

====Кластерный элемент ====

''Определение.'' Пусть в кластере содержатся <math>N</math> точек размерности <math>d</math>:<math>\{\vec{X_i}\}</math>, где <math>i=1,2,...,N</math>.
'''Кластерный элемент (CF)''' - тройка чисел, характеризующая информацию о кластере:
<math>CF = (N, \vec{LS}, SS)</math>, где <math>N</math> - количество элементов входных данных, содержащихся в кластере, <math>\vec{LS}</math> - линейная сумма входных данных (т.е. <math>\sum_{i=1}^{N}\vec{X_i}</math>), <math>SS</math> - сумма квадратов входных данных (т.е. <math>\sum_{i=1}^{N}{\vec{X_i}}^2</math>)

'''Теорема''' Пусть <math>CF_1 = (N_1, \vec{LS_1}, SS_1)</math> и <math>CF_2 = (N_1, \vec{LS_2}, SS_2)</math> - CF векторы двух непересекающихся кластеров. Тогда при их объединении образуется кластер со следующим CF вектором:

<math>CF = CF_1 + CF_2 = (N_1+N_2, \vec{LS_1}+\vec{LS_2}, SS_1+SS_2)</math>.

Из указанных выше определения и теоремы вытекает тот факт, что при объединении кластеров их CF вектор может вычисляться инкрементно и точно.
Легко показать, что вычислить величины <math>\vec{X_0}</math>, <math>R</math>, <math>D</math>, <math>D_0</math>, <math>D_1</math>, <math>D_2</math>, <math>D_3</math>, <math>D_4</math>, как и обычные метрики, также не составит труда.

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

==== Кластерное дерево ====

''Определение.'' '''Кластерное дерево (CF Tree)''' - это взвешенно сбалансированное дерево с двумя параметрами: <math>B</math> - коэффициент разветвления, <math>T</math> - пороговая величина.

Каждый нелистьевой узел дерева имеет не более чем <math>B</math> вхождений узлов следующей формы: <math>[CF_i,child_i]</math>, где <math>i=1,2,...,B</math>, ''child'' - указатель на i-й дочерний узел, <math>CF_i</math> - CF вектор соответствующего подкластера.

Каждый листьевой узел имеет ссылку на два соседних узла (''prev'' и ''next'') для того, чтобы связать все узлы для эффективного сканирования.
Все листьевые узлы должны удовлетворять пороговому ограничению <math>T</math>, т.е. диаметр (радиус) не должен превосходить <math>T</math>.
В процессе вставки новых данных CF дерево строится динамически. Оно использует вставку данных для кластеризации точно также как <math>B+</math> [https://ru.wikipedia.org/wiki/B%2B-%D0%B4%D0%B5%D1%80%D0%B5%D0%B2%D0%BE дерево] использует её для поиска.
CF дерево очень компактно, поскольку каждый листьевой узел - это не просто точка, а подкластер (который объединяет множество точек с учётом ограничения <math>T</math>).

==== Операция вставки в '''CF''' дерево ====

Опишем алгоритм вставки элемнта <math>Ent</math> в CF дерево:

1) ''Определение подходящего листа'': Начиная с корня, алгоритм рекурсивно спускается по CF дереву, выбирая '''ближайший''' дочерний узел в соответствии с выбранной метрикой <math>D0</math>, <math>D1</math>, <math>D2</math>, <math>D3</math> или <math>D4</math>.

2) ''Преобразование листа'': Когда алгоритм доходит до листа, он находит ближайшую листьевой элемент, скажем, <math>L_1</math>, а затем проверяет, можно ли добавить ''Ent'' к <math>L_1</math> без нарушения порогового условия. Если да, то с учётом этого изменяется CF вектор для <math>L_1</math>; если нет, то ''Ent'' становится новым элементом листа. Если в листе для этого достаточно места, то шаг окончен, иначе он должен "расщепиться". Расщепление узла производится при помощи выбора за основу наиболее удалённой друг от друга пары элементов и перераспределение оставшихся элементов в соответствии с выбранным критерием близости.

3) ''Преобразование пути к листу'': После вставки ''Ent'' в лист мы должны обновить информацию о CF для каждого нелистьевого элемента на пути к листу. При отсутствии расщепления это означает простое сложение CF векторов для отражения факта добавления ''Ent''. Расщепление листа же требует вставки нового нелистьевого элемента в родительский узел для задания только что созданного листа. Если у родителя есть место для этого элемента, то необходимо просто преобразовать CF векторы на всех более высоких уровнях. В общем случае, однако, нам также придётся расщепить родительский узел, и так далее до корня. Если расщеплён корень, то высота дерева увеличивается на единицу.

4) ''Улучшение слияния'': Расщепление вызвано ограничением на размер узла, который не зависит от кластеризационных свойств данных. Если во входящем потоке присутствуют "искажённые" (из областей с низкой плотностью) данные, это может повлиять на качество кластеризации, а также уменьшить эффективность использования памяти. Дополнительный шаг алгоритма помогает решить эти проблемы: предположим, что произошло расщепление листа, и распространение этого процесса остановилось на некотором нелистьевом узле <math>N_j</math>, то есть <math>N_j</math> может вместить дополнительный элемент, полученный после расщепления. Теперь мы сканируем узел <math>N_j</math> для нахождения двух наиболее близких элементов. Если это не пара, отвечающая расщеплению, мы пытаемся объединить их и поставить в соответствие два дочерних узла. Если количество элементов в дочерних узлах больше B, мы снова расщепляем результат объединения.
В процессе повторного расщепления, в случае, если один источник собирает достаточно элементов для того, чтобы полностью заполнить узел, оставшиеся элементы передаются другом источнику. В итоге, если объединённые элементы помещаются в одном узле, в нём освобождается место для ещё одного элемента. Тем самым увеличивается степень использования свободного пространства и откладывается дальнейшее расщепление. В ином случае мы улучшаем распределение элементов в двух ближайших подкластерах.

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

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

* радиуса <math>R</math> или диаметра <math>D</math> кластерного элемента. Выполняется при попытке вставить новый элемент в один из подкластеров листьевого узла дерева.

* расстояния между двумя элементами. Выполняется при поиске ближайшего по отношению к новому элементу подкластера в узле дерева по одной из рассмотренных в разд. 1.2.1 метрик <math>D_0</math>, <math>D_1</math>, <math>D_2</math>, <math>D_3</math> или <math>D_4</math>.

Зная характеристики кластерных элементов <math>N</math>, <math>\vec{LS}</math> и <math>S</math>, в результате алгебраических преобразований можно получить следующие упрощенные формулы вычисления необходимых значений:

<math>\vec{X_0} = \frac{\vec{LS}}{N}</math>

<math>R = (\frac{SS - 2\vec{X_0}\vec{LS} + N(\vec{X_0})^2}{N})^{1/2}</math>

<math>D = (\frac{2(N \cdot SS - (\vec{LS})^2)}{N(N-1)})^{1/2}</math>

<math>D_2 = (\frac{N_1 \cdot SS_2 + N_2 \cdot SS_1 - 2\vec{LS_1}\vec{LS_2}}{N_1 \cdot N_2})^{1/2}</math>

<math>D_3 = (\frac{2((N_1+N_2)(SS_1+SS_2)-(\vec{LS_1}+\vec{LS_2})^2)}{(N_1+N_2)(N_1+N_2-1)})^{1/2}</math>

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

Реализация алгоритма BIRCH состояит из следующих четырёх фаз:

* '''Фаза 1'''. Главной задачей фазы 1 является сканирование всех данных и построение в памяти исходного CF дерева, используя заданное количество памяти. Это дерево стремится отразить информацию о кластеризации данных настолько хорошо, насколько это позволяют ограничения по памяти. При этом плотно распределённые данные группируются в подкластеры, а более разрозненные данные удаляются. После завершения фазы 1 вспомогательные вычисления в дальнейших фазах будут:

1) быстрее, потому что (а) больше не нужны операции ввода-вывода, (b) проблема кластеризации начальных данных упрощается до проблемы кластеризации подкластеров в листьях;

2) точнее, потому что (а) большинство данных с низкой плотностью удалены, (b) оставшиеся данные распределены оптимально (в соответствии с доступным количеством памяти);

* '''Фаза 2'''. Данная фаза является опциональной. Известно, что существующие методы глобальной кластеризации, используемые в рамках фазы 3, имеют различные диапазоны входных значений, при которых их реализация наиболее эффективна. Поэтому потенциально существует пробел между размером фазы 1 и входными значениями фазы 3. И фаза 2 как раз является недостающим связующим звеном: так же как и фаза 1, она сканирует листьевые элементы начального CF дерева для того, чтобы построить меньшее дерево, удаляя ещё больше элементов с низкой плотностью и группируя переполненные подкластеры в большие кластеры.

* '''Фаза 3'''. В данной фазе для листьевых элементов применяется (любой подходящий) алгоритм глобальной кластеризации. Существующие алгоритмы кластеризации наборов точек могут также работать с наборами подкластеров, каждый из которых представлен своим CF вектором. Зная CF вектор, можно вычислить центроид и в дальнейшем заменить всю информацию о кластере этим значением (этого достаточно для вычисления большинства необходимых метрик). После фазы 3 мы получаем набор кластеров, который отражает основные характеристики распределяемых данных.
Однако, всё ещё могут оставаться некоторые неточности, для устранения которых существует фаза 4.

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

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

<source lang="c++">
void CF_Node::insert(const CF_Cluster &entry)
{
//Находим ближайший к новому элементу подкластер в узле
СF_Vector_it closest = entry.findClosest(subclusters);
//Если узел пустой, добавляем в него новый подкластер
if (closest == subclusters.end()) {
subclusters.push_back(entry);
return;
}
closest->add(entry);
//Если узел является листьевым, и ближайший подкластер не может вместить
//новый элемент, добавляем в узел новый подкластер
if (leaf) {
if (closest->D > threshold) {
closest->remove(entry);
subclusters.push_back(entry);
}
}
else {
CF_Node *node = closest->child;
node->insert(entry);
//Если при добавлении нового элемента в дочерний узел тот переполнился,
//расщепляем его
if (node->getSubclusters().size() > bFactor) {
CF_Vector newClusters = node->splitNode();
delete node;
subclusters.erase(closest);
subclusters.insert(subclusters.end(), newClusters.begin(), newClusters.end());
}
}
//Если узел является корневым и он переполнен, расщепляем его
if (root && subclusters.size() > bFactor) {
subclusters = splitNode();
leaf = false;
}
}

CF_Vector CF_Node::splitNode()
{
if (subclusters.size() < 2)
return (root) ? subclusters : CF_Vector{CF_Cluster(this)};
//Находим пару наиболее удаленных друг от друга подкластеров
CF_Vector_it pole1, pole2;
data_t longestDist = 0.0;
for (auto lhs = subclusters.begin(); lhs != subclusters.end() - 1; ++lhs) {
for (auto rhs = lhs + 1; rhs != subclusters.end(); ++rhs) {
auto distance = getDistance(*lhs, *rhs);
if (distance > longestDist) {
longestDist = distance;
pole1 = lhs;
pole2 = rhs;
}
}
}
//Разделяем множество всех подкластеров узла на две части
CF_Vector subclusters1, subclusters2;
for (auto it = subclusters.begin(); it != subclusters.end(); ++it) {
if (getDistance(*it, *pole1) < getDistance(*it, *pole2))
subclusters1.push_back(*it);
else
subclusters2.push_back(*it);
}
//Создаем два новых узла
CF_Node *node1 = new CF_Node(threshold, bFactor, count, leaf, subclusters1),
*node2 = new CF_Node(threshold, bFactor, count, leaf, subclusters2);
//Связываем листья
if (leaf) {
if (prevLeaf) {
node1->setPrevLeaf(prevLeaf);
prevLeaf->setNextLeaf(node1);
}
if (nextLeaf) {
node2->setNextLeaf(nextLeaf);
nextLeaf->setPrevLeaf(node2);
}
node1->setNextLeaf(node2);
node2->setPrevLeaf(node1);
}
CF_Cluster cluster1(node1), cluster2(node2);
return CF_Vector{cluster1, cluster2};
}
</source>

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

Для начала проанализируем вычислительную сложность фазы 1.
Максимальный размер дерева <math>\frac{M}{P}</math>, где <math>P</math> - ограничение по памяти на размер узла, а <math>M</math> - общий объем памяти. Для того чтобы вставить элемент, мы должны пройти путь от корня до листа (это около <math>1+log_B\frac{M}{P}</math> узлов). В каждом узле в поисках "ближайшего" нам необходимо просмотреть B элементов; сложность для каждого элемента пропорциональна размерности ''d''.

Поэтому сложность вставки всех входных точек <math>O(d \cdot N \cdot B(1+log_B\frac{M}{P}))</math>.

В случае, когда необходимо перестроить дерево, предположим, что ES - это размер CF элемента. Существует максимум <math>\frac{M}{ES}</math> листьевых элементов для вставки, поэтому сложность повторной вставки листьевых элементов <math>O(d \cdot \frac{M}{ES} \cdot B(1+log_B\frac{M}{P}))</math>.

Количество итераций перестройки дерева зависит от пороговой величины. На самом деле, это около <math>log_2\frac{N}{N_0}</math> (двоичное основание появилось из-за того, что мы не можем провести оценку более чем в 2 раза отличающуюся от текущего размера). <math>N_0</math> - это число входных точек, загруженных в память с пороговым ограничением <math>T_0</math>.

Соответственно, итоговая сложность фазы 1 <math>O(d \cdot N \cdot B(1+log_B\frac{M}{P})+log_2\frac{N}{N_0} \cdot d \cdot \frac{M}{ES} \cdot B(1+log_B\frac{M}{P}))</math>.

Анализ фазы 2 проводится аналогично.

Что касается операций ввода-вывода, то в фазе 1 данные сканируются один раз, а в фазе 2 не сканируются вовсе.
Некоторое количество вычислений связано с удалением точек из областей с низкой плотностью.
Если количество доступной для этой операции памяти не больше ''M'' и проведено порядка <math>log_2\frac{N}{N_0}</math> перестроек дерева, то сложность ввода-вывода для фазы 1 существенно не отличается от сложности чтения из файла. Основываясь рассуждениях выше, сложность фаз 1 и 2 будет линейно увеличиваться с ростом N.

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

Фаза 4 снова сканирует данные и записывает каждую точку в подходящий кластер; время работы пропорционально <math>N \cdot K</math>.

<math></math>

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

=== Вычисление расстояния ===

<math>D_2=\frac{N_1\cdot SS_2+N_2\cdot SS_1-2 \cdot \vec{LS_1}\cdot \vec{LS_2}}{N_1\cdot N_2}</math>, где

<math>CF_1=[N_1,\vec{LS_1},SS_1]</math>

<math>CF_2=[N_2,\vec{LS_2},SS_2]</math>

[[File:ZgYL51QJsQk.jpg|600px|thumb|center]]

=== Поиск ближайшего подкластера ===

<math>E</math> - новый элемент

<math>CF_i, i = 1,...,B</math> - подкластеры узла

<math>m</math> - операция min

<math>\rho</math> - нахождение расстояния

[[File:PFA16KHUQ3I.jpg|600px|thumb|center]]

=== Скалярное произведение ===

<math>s = \vec{x}\cdot\vec{y}=\sum_{i=1}^d x_i\cdot y_i</math>

[[File:Xb7FYXVMPpQ.jpg|600px|thumb|center]]

<math></math>

== Ресурс параллелизма алгоритма ==
Параллельно могут быть выполнены следующие шаги алгоритма:
* Нахождение ближайшего к новому элементу подкластера в узле при выполнении операции вставки. Это возможно за счет того, что расстояние между парами элементов может быть вычислено независимо друг от друга.
* Вычисление величин <math>\vec{LS},\vec{X0}, R, D, D_0-D_4</math>, в процессе чего выполняются операции сложения и скалярного произведения векторов.

Таким образом, параллельная сложность фазы 1 алгоритма будет равна <math>O((N + log_2\frac{N}{N_0} \cdot \frac{M}{ES})(log_2 B + log_2 d)(1+log_B\frac{M}{P}))</math>

Другим способом параллелизации алгоритма может служить создание и заполнение сразу множества кластерных деревьев, между которыми будут распределены входные данные. Множество всех подкластеров листьевых узлов полученных таким образом деревьев может быть подвергнуто глобальной кластеризации с помощью какого-либо из известных параллельных алгоритмов, например, k-средних<ref>[A Garg, N Gupta PBIRCH: A Scalable Parallel Clustering algorithm for Incremental Data //10th International Database Engineering and Applications Symposium (IDEAS'06), 2006</ref>.

== Входные и выходные данные алгоритма ==
'''Входные данные:''' набор из <math>N</math> точек <math>\{X_i\}, i=1,...,N</math> размерности <math>d</math>.

'''Объем входных данных:''' <math>N \cdot d</math>

'''Выходные данные:''' кластерное дерево с не более чем <math>\frac{M}{P}</math> узлами.

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

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

Вычислительная мощность алгоритма имеет порядок <math>O(\frac{d \cdot B \cdot (1+log_B\frac{M}{P}) \cdot (N +log_2\frac{N}{N_0} \cdot \frac{M}{ES})}{N \cdot d + M})</math>

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

К достоинствам алгоритма можно отнести следующие его свойства:

1. BIRCH является локальным алгоритмом, то есть каждое решение о каждом элементе кластера принимается без повторного сканирования данных или уже существующих кластеров. Используются только метрики, отражающие близость элементов друг к другу.

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

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

4. BIRCH не требует всего набора данных заранее (при этом просматривает его всего один раз).

В свою очередь, недостатки алгоритма можно сформулировать следующим образом:

1. Алгоритм позволяет работать только с числовыми данными.

2. BIRCH хорошо выделяет только кластеры сферической формы.

3. Существует необходимость в задании пороговых значений.

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

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

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

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

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

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

[[file:Масштабируемость параллельной реализации алгоритма BIRCH. Производительность.png|thumb|center|700px|Рисунок 1. График времени работы параллельной реализации алгоритма BIRCH. ]]

[[file:Масштабируемость параллельной реализации алгоритма BIRCH. Эффективность.png|thumb|center|700px|Рисунок 2. График эффективности распараллеливания алгоритма BIRCH относительно последовательной реализации. ]]

Набор изменяемых параметров запуска реализации алгоритма и границы значений параметров алгоритма:
* число процессоров [8 : 80] с шагом 8
* число точек [100 000 : 1 000 000] с шагом 100 000

В результате проведённых экспериментов был получен следующий диапазон эффективности реализации алгоритма:
* минимальная эффективность реализации 9,13% (80 процессоров, 100 000 точек)
* максимальная эффективность реализации 235,42% (8 процессоров, 800 000 точек)

Полученные результаты могут быть объяснены недерминированностью алгоритма BIRCH и существенной зависимостью времени его работы от входных данных.

Оценка масштабируемости параллельной реализации:
* По числу процессов: при увеличении числа процессов эффективность распараллеливания снижается. При количестве процессов <math>n>30</math> темп снижения становится несущественным.
* По размеру задачи: при увеличении размера входных данных эффективность растет неравномерно, что свидетельствует о сложной зависимости от входных данных.

Для исследования возможностей паралеллизма алгоритма BIRCH была написана [https://github.com/duran-duran/birch реализация на языке C++] с использованием технологии MPI. В данной реализации входные данные равномерно распределяются между всеми процессами, в каждом из которых выполняется построение собственного кластерного дерева. Листьевые элементы полученных деревьев затем подвергаются глобальной кластеризации с помощью распределенного алгоритма k-средних. В качестве входных данных использовались точки размерности <math>d=5</math>, координаты которых были равномерно распределены в диапазоне <math>[-10000;10000]</math>.

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

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

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

В составе пакетов и библиотек:
* [http://scikit-learn.org/stable/modules/generated/sklearn.cluster.Birch.html scikit-learn]
* [http://cucis.ece.northwestern.edu/projects/DMS/MineBench.html NU-MineBench]
Пользовательские реализации:
* [https://code.google.com/archive/p/jbirch/ JBIRCH]

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

Обсуждение участника:Светлана Морозова

2016-12-12T09:57:03Z

Coctic:

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

2016-12-05T07:31:34Z

Coctic:

= Статья [[Нечеткий алгоритм С средних]] =
* не указан вклад каждого автора [[Участник:Coctic|Coctic]] ([[Обсуждение участника:Coctic|обсуждение]]) 12:58, 25 октября 2016 (MSK) - исправлено
:: Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 13:29, 31 октября 2016 (MSK)
* п. 1.9 не приведены оценки объема входных и выходных данных [[Участник:Coctic|Coctic]] ([[Обсуждение участника:Coctic|обсуждение]]) 12:58, 25 октября 2016 (MSK) - исправлено
:: Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 13:29, 31 октября 2016 (MSK)
* п. 2.4. Не приведена ссылка на текст исследуемой программы [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 18:28, 16 ноября 2016 (MSK)
** Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 10:32, 28 ноября 2016 (MSK)
* п. 2.4. Не указана аппаратная платформа, на которой проводилось тестирование [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 18:28, 16 ноября 2016 (MSK)
** Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 10:32, 28 ноября 2016 (MSK)
* п. 2.4. На рис. 2 и 3 подпись вертикальной оси накладывается на подписи шкалы [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 18:28, 16 ноября 2016 (MSK)
** Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 10:32, 28 ноября 2016 (MSK)
* п. 2.4. Не приведено никаких сведений о масштабируемости исследуемой программы. На рис. 2 и 3 приведены графики зависимости некоей "сложности" (какя сложность имеется в виду - не указано) от разных параметров. Как из этих графиков извлечь сведения о масштабируемости - не указано. [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 18:28, 16 ноября 2016 (MSK)
** Исправлено частично. В осях стало время в секундах, в подписях к рисункам по-прежнему непонятная "сложность". Что в итоге на рисунках - неясно. [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 10:32, 28 ноября 2016 (MSK)
*** Указали в подписях к рисункам "зависимость времени работы"
**** Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 10:31, 5 декабря 2016 (MSK)
* Графики на рис. 2 и 3 плохо читаются [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 10:32, 28 ноября 2016 (MSK)
** Добавили цветные поверхности
*** Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 10:31, 5 декабря 2016 (MSK)
* Необходимо указать характеристики программно-аппаратной платформы (какой компилятор, с какими опциями использовался, какие версии библиотек, на каких узлах проводился запуск и т.д.) [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 10:32, 28 ноября 2016 (MSK)
**Указали компилятор и характеристики узлов на IBM Blue Gene/P
*** Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 10:31, 5 декабря 2016 (MSK)

Участник:Demon smd/Нечеткий алгоритм С средних

2016-12-05T07:31:04Z

Coctic:

{{Assignment|{{REVISIONUSER}}}}

{{algorithm
| name = Нечеткий алгоритм C средних (Fuzzy C-means)
| serial_complexity = <math>O(C^2*N*D*IterNumber)</math>
| pf_height = <math>O(\log_{2}C^4*|X|^3) * IterNumber</math>
| pf_width = <math>O(C^2*|X|)</math>
| input_data = <math>|X|*p</math>, где <math>p</math> - размерность входных векторов
| output_data = <math>|X|*C </math>
}}

Авторы описания алгоритма:
[[Участник:Demon smd|Д.А.Гуськов]]
[[Участник:marina abramenkova|М.А.Абраменкова]]
Во все разделы вклад равноценный.

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

=== Общее описание алгоритма ===
Нечёткий алгоритм кластеризации С-средних был разработан (для случая m=2) J.C. Dunn в 1973 г.
<ref>Dunn, J. C. (1973-01-01). "A Fuzzy Relative of the ISODATA Process and Its Use in Detecting Compact Well-Separated Clusters". Journal of Cybernetics. 3 (3): 32–57. doi:10.1080/01969727308546046. ISSN 0022-0280.</ref>
и усовершенствован (для случая m>1)
J.C. Bezdek в 1981 г. <ref>Bezdek, James C. (1981). Pattern Recognition with Fuzzy Objective Function Algorithms. ISBN 0-306-40671-3.</ref>
. В отличие от алгоритма c-means данный метод кластеризации предполагает, что входные данные могут принадлежать более, чем одному кластеру одновременно.
Алгоритм получает на вход набор кластеризуемых векторов, количество кластеров, коэффициент неопределённости m и коэффициент <math>\varepsilon > 0</math>, определяющий точность алгоритма. На выходе алгоритма получаем матрицу вероятностей принадлежности каждого входного вектора каждому кластеру.

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

1) расчёт центров кластеров

2) расчёт Евклидова расстояния от каждого вектора до центра каждого кластера

3) расчёт и нормализация коэффициентов принадлежности векторов кластерам

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

=== Математическое описание алгоритма ===
Нечеткий алгоритм С средних минимизирует величину:
:<math>
\begin{align}
J_{m} = \sum_{i = 1}^{N}\sum_{j = 1}^{C}u_{i,j}^m\left\Vert{x_{i}-c_{j}}\right\|^2 & , & & 1 \le m \le \infty , \\
\end{align}
</math>
где m - это действительное число не меньше единицы, <math>u_{i,j}</math> - коэффициент принадлежности вектора <math>x_{i}</math> к кластеру <math>c_{j}</math>, <math>x_{i}</math> - <math>i</math>-ый компонент <math>N</math>-мерного вектора <math>x</math>, <math>c_{j}</math>
- центр <math>j</math>-ого кластера, а <math>\left\Vert{*}\right\|</math> - это любая норма, определяющая расстояние от вектора до центра кластера.
Нечёткое разбиение входных данных на кластеры производится итеративной оптимизацией вышеуказанной функции с обновлением коэффициента принадлежности <math>u_{i,j}</math> и переопределением центра кластера <math>c_{j}</math> на каждой итерации алгоритма.

==== Вычисляемые данные на каждой итерации ====
* Центры кластеров рассчитываются по следующей формуле: <math>c_{j} = {{\sum_{i = 1}^{n}{u_{i,j}^m} * x_{i}} \over {\sum_{i = 1}^{n}{u_{i,j}^m}}}</math>, где <math>u_{i,j}</math> — коэффициент принадлежности <math>x_{i}</math> вектора к кластеру <math>c_{j}</math>.

* Коэффициент принадлежности рассчитывается по формуле: <math>u_{i,j} = {1 \over \sum_{k = 1}^{C}{({\left\Vert{x_{i}-c_{j}}\right\| \over \left\Vert{x_{i}-c_{k}}\right\|})}^{2 \over m-1}}</math>

* Решающая функция рассчитывается по формуле: <math>\max_{i,j}(|u_{i,j}^{(k)} - u_{i,j}^{(k-1)}|)</math>, где <math>k</math> - номер итерации алгоритма

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

Ядром алгоритма является:
* вычисление новых центров кластеров
* для каждого входного вектора вычисление Евклидова расстояния до центров кластеров, а также коэффициента принадлежности кластерам
* вычисление решающей функции

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

В каждой итерации алгоритма происходит 3 основных действия описанных в п. 1.2.1:
*вычисление центров кластеров
*вычисление коэффициентов принадлежности
*вычисление решающей функции
Подробное описание макроструктур в виде кода приведено в пункте 1.5

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

Схему реализации последовательного алгоритма можно описать на C++ следующим образом:

<source lang="C++">

FCM (X[], C, m, eps){
float deside = 0;
float newDeside = 0;
generateMembershipDegree(); //заполняет uPrev[][] случайными нормрованными коэффициентами
while (true){
newDeside = deside;

//вычисление центров кластеров
for (int j=0; j<C; j++){ //для каждого кластера
float numerator = 0;
float denumerator = 0;
for (int i=0; i<X.size(); i++){ //для каждого вектора
numerator+=pow(u[i][j], m) * x[i];
denumerator+=pow(u[i][j], m);
}
c[j] = numerator / denumerator;
}

//вычисление коэффициентов u[][]
for (int i=0; i<X.size(); i++) //для каждого вектора
for (int j=0; j<C; j++){ //для каждого кластера
sum = 0;
for (int k=0; k<C; k++)
sum+= pow( dist(x[i], c[j]) / dist(x[i], c[k]), 2/(m-1));
u[i][j] = 1/sum
}

//определения максимального различия между u[][] и uPrev[][]
float max = 0;
for (int i=0; i<X.size(); i++) //для каждого вектора
for (int j=0; j<C; j++){ //для каждого кластера
if (abs(uPrev[i][j]-u[i][j])>max)
max = abs(uPrev[i][j]-u[i][j]);

if (eps <= max)
for (int i=0; i<X.size(); i++) //для каждого вектора
for (int j=0; j<C; j++){ //для каждого кластера
uPrev[i][j]=u[i][j];
else
break;

}
return u;
}
</source>

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

Последовательная сложность всего алгоритма складывается из сложности операций на каждой итерации умноженную на количество итераций. Так как в данном алгоритме количество итераций не является фиксированным и зависит от:
* параметра <math>\varepsilon</math>
* набора входных векторов <math>x</math>
* выбора начальных коэффициентов <math>u</math>
то в данном пункте будет приведена сложность одной итерации относительно количества входных векторов.
Как видно из предыдущего пункта, для вычисления центров кластеров требуется <math>O(2*C*|X|)</math> операций, для определения коэффициентов <math>u</math> - <math>O(C^2*|X|)</math> операций, а для вычисления решающей функции - <math>O(2*C*|X|)</math> операций, где <math>|X|</math> - число входных векторов, а <math>C</math> - количество кластеров.

Таким образом итоговая сложность одной итерации составляет <math>O(C^2*|X|)</math>.

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

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

[[File:FCMIG.png|thumb|center|1200px|Рисунок 1. Информационный граф алгоритма. (1)-(7) - это наборы последовательных действий (например, (2) - последовательные операции деления, взятия адреса и присваивания).]]

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

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

Сложность алгоритма будем рассчитывать в предположении, что число вычислительных ядер стремится к бесконечности. Как видно из информационного графа, параллельная сложность вычисления центров кластеров составляет <math>O(\log_{2} C*|X|)</math>, вычисления коэффициентов принадлежности - <math>O(\log_{2} C^2*|X|)</math>, а вычисления решающей функции - не больше чем <math>O(\log_{2} C*|X|)</math>.

Таким образом параллельная сложность итерации алгоритма составляет <math>O(\log_{2} C^4*|X|^3)</math>.

Так как задачи, решаемые в макроструктуре алгоритма могут быть сведены к задачам вычисления суммы элементов массива и максимального элемента массива, то на <math>i</math>-ом ярусе графа будет находиться <math>{N}\over{2^i}</math> операции, где N - количество элементов массива.

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

==== Входные данные алгоритма ====
* <math>X</math> - набор из <math>|X|</math> входных векторов длины <math>p</math>
* <math>C</math> - количество кластеров
* <math>m</math> - коэффициент неопределённости
* <math>\varepsilon > 0</math> - коэффициент, определяющий точность алгоритма.

Объем входных данных: <math>|X|*p+3</math>

==== Выходные данные алгоритма ====
* <math>u</math> - матрица принадлежности векторов кластерам

Объем выходных данных: <math>|X|*C</math>

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

Увеличение скорости работы алгоритма при распараллеливании на бесконечном количестве процессоров составляет <math>O({{C^2*|X|}\over{\log_{2} (C^4*|X|^3)}})</math>. Например, для разбиения 1000 элементов на 10 кластеров производительность параллельного алгоритма будет в 2315 раз больше, а на 20 кластеров - уже в 8477 раз.

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

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

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

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

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

Как видно из предыдущих пунктов, масштабируется данный алгоритм хорошо. С увеличением количества процессоров время работы падает, а с увеличением количества входных данных и количества кластеров - растёт.
На рисунках показаны результаты запусков алгоритма на разном количестве входных данных и процессоров на массивно-параллельной вычислительной системе Blue Gene/P. Использовался компилятор mpixlcxx без указания специфических опций. Запуски производились в режиме SMP (на каждом ядре 1 MPI процесс из 4 SMP нитей, 2 Гб памяти). Характеристики вычислительного узла: 4 ядерный 32-битный процессор PowerPC 850 Мгц.

Исходных код программы можно найти здесь: https://github.com/demonsmd/superPrak
[[File:FCMvectors_color2.png|thumb|center|1250px|Рисунок 2. Масштабируемость алгоритма. Зависимость времени работы алгоритма от количества процессоров и входных данных при фиксированном количестве кластеров.]]
[[File:FCMclusters_color.png|thumb|center|1250px|Рисунок 3. Масштабируемость алгоритма. Зависимость времени работы алгоритма от количества процессоров и кластеров при фиксированном количестве входных данных.]]

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

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

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

Существует множество реализаций данного алгоритма. Рассмотрим некоторые из них:

- Например, тут: https://habrahabr.ru/post/208496/
<ref>Нестер А. "Алгоритм нечёткой кластеризации fuzzy c-means на PHP". [html](https://habrahabr.ru/post/208496/)</ref>
приведено краткое описание алгоритма и приведена его реализация на php. В данной статье довольно подробно расписан каждый шаг алгоритма и приведён соответствующий ему фрагмент кода.

- Тут: http://num-meth.srcc.msu.ru/zhurnal/tom_2012/v13r207.html
<ref>Миниахметов Р.М., Цымблер М.Л. "Интеграция алгоритма кластеризации Fuzzy c-Means в PostgreSQL". [html](http://num-meth.srcc.msu.ru/zhurnal/tom_2012/v13r207.html)</ref>
приводится реализация алгоритма для PostgreSQL, а также прилагается скрипт внедрения алгоритма.

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

<references \>

Участник:Coctic

2016-11-30T14:49:35Z

Coctic:

Константин Стефанов, к.ф.-м.н. с.н.с. лаб. параллельных информационных технологий НИВЦ МГУ

Участник:Coctic

2016-11-30T14:48:48Z

Coctic: Новая страница: «Константин Стефанов, с.н.с. лаб. параллельных информационных технологий НИВЦ МГУ»

Константин Стефанов, с.н.с. лаб. параллельных информационных технологий НИВЦ МГУ

Участник:Demon smd/Нечеткий алгоритм С средних

2016-11-28T07:32:45Z

Coctic:

{{algorithm
| name = Нечеткий алгоритм C средних (Fuzzy C-means)
| serial_complexity = <math>O(C^2*N*D*IterNumber)</math>
| pf_height = <math>O(\log_{2}C^4*|X|^3) * IterNumber</math>
| pf_width = <math>O(C^2*|X|)</math>
| input_data = <math>|X|*p</math>, где <math>p</math> - размерность входных векторов
| output_data = <math>|X|*C </math>
}}

Авторы описания алгоритма:
[[Участник:Demon smd|Д.А.Гуськов]]
[[Участник:marina abramenkova|М.А.Абраменкова]]
Во все разделы вклад равноценный.

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

=== Общее описание алгоритма ===
Нечёткий алгоритм кластеризации С-средних был разработан (для случая m=2) J.C. Dunn в 1973 г.
<ref>Dunn, J. C. (1973-01-01). "A Fuzzy Relative of the ISODATA Process and Its Use in Detecting Compact Well-Separated Clusters". Journal of Cybernetics. 3 (3): 32–57. doi:10.1080/01969727308546046. ISSN 0022-0280.</ref>
и усовершенствован (для случая m>1)
J.C. Bezdek в 1981 г. <ref>Bezdek, James C. (1981). Pattern Recognition with Fuzzy Objective Function Algorithms. ISBN 0-306-40671-3.</ref>
. В отличие от алгоритма c-means данный метод кластеризации предполагает, что входные данные могут принадлежать более, чем одному кластеру одновременно.
Алгоритм получает на вход набор кластеризуемых векторов, количество кластеров, коэффициент неопределённости m и коэффициент <math>\varepsilon > 0</math>, определяющий точность алгоритма. На выходе алгоритма получаем матрицу вероятностей принадлежности каждого входного вектора каждому кластеру.

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

1) расчёт центров кластеров

2) расчёт Евклидова расстояния от каждого вектора до центра каждого кластера

3) расчёт и нормализация коэффициентов принадлежности векторов кластерам

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

=== Математическое описание алгоритма ===
Нечеткий алгоритм С средних минимизирует величину:
:<math>
\begin{align}
J_{m} = \sum_{i = 1}^{N}\sum_{j = 1}^{C}u_{i,j}^m\left\Vert{x_{i}-c_{j}}\right\|^2 & , & & 1 \le m \le \infty , \\
\end{align}
</math>
где m - это действительное число не меньше единицы, <math>u_{i,j}</math> - коэффициент принадлежности вектора <math>x_{i}</math> к кластеру <math>c_{j}</math>, <math>x_{i}</math> - <math>i</math>-ый компонент <math>N</math>-мерного вектора <math>x</math>, <math>c_{j}</math>
- центр <math>j</math>-ого кластера, а <math>\left\Vert{*}\right\|</math> - это любая норма, определяющая расстояние от вектора до центра кластера.
Нечёткое разбиение входных данных на кластеры производится итеративной оптимизацией вышеуказанной функции с обновлением коэффициента принадлежности <math>u_{i,j}</math> и переопределением центра кластера <math>c_{j}</math> на каждой итерации алгоритма.

==== Вычисляемые данные на каждой итерации ====
* Центры кластеров рассчитываются по следующей формуле: <math>c_{j} = {{\sum_{i = 1}^{n}{u_{i,j}^m} * x_{i}} \over {\sum_{i = 1}^{n}{u_{i,j}^m}}}</math>, где <math>u_{i,j}</math> — коэффициент принадлежности <math>x_{i}</math> вектора к кластеру <math>c_{j}</math>.

* Коэффициент принадлежности рассчитывается по формуле: <math>u_{i,j} = {1 \over \sum_{k = 1}^{C}{({\left\Vert{x_{i}-c_{j}}\right\| \over \left\Vert{x_{i}-c_{k}}\right\|})}^{2 \over m-1}}</math>

* Решающая функция рассчитывается по формуле: <math>\max_{i,j}(|u_{i,j}^{(k)} - u_{i,j}^{(k-1)}|)</math>, где <math>k</math> - номер итерации алгоритма

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

Ядром алгоритма является:
* вычисление новых центров кластеров
* для каждого входного вектора вычисление Евклидова расстояния до центров кластеров, а также коэффициента принадлежности кластерам
* вычисление решающей функции

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

В каждой итерации алгоритма происходит 3 основных действия описанных в п. 1.2.1:
*вычисление центров кластеров
*вычисление коэффициентов принадлежности
*вычисление решающей функции
Подробное описание макроструктур в виде кода приведено в пункте 1.5

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

Схему реализации последовательного алгоритма можно описать на C++ следующим образом:

<source lang="C++">

FCM (X[], C, m, eps){
float deside = 0;
float newDeside = 0;
generateMembershipDegree(); //заполняет uPrev[][] случайными нормрованными коэффициентами
while (true){
newDeside = deside;

//вычисление центров кластеров
for (int j=0; j<C; j++){ //для каждого кластера
float numerator = 0;
float denumerator = 0;
for (int i=0; i<X.size(); i++){ //для каждого вектора
numerator+=pow(u[i][j], m) * x[i];
denumerator+=pow(u[i][j], m);
}
c[j] = numerator / denumerator;
}

//вычисление коэффициентов u[][]
for (int i=0; i<X.size(); i++) //для каждого вектора
for (int j=0; j<C; j++){ //для каждого кластера
sum = 0;
for (int k=0; k<C; k++)
sum+= pow( dist(x[i], c[j]) / dist(x[i], c[k]), 2/(m-1));
u[i][j] = 1/sum
}

//определения максимального различия между u[][] и uPrev[][]
float max = 0;
for (int i=0; i<X.size(); i++) //для каждого вектора
for (int j=0; j<C; j++){ //для каждого кластера
if (abs(uPrev[i][j]-u[i][j])>max)
max = abs(uPrev[i][j]-u[i][j]);

if (eps <= max)
for (int i=0; i<X.size(); i++) //для каждого вектора
for (int j=0; j<C; j++){ //для каждого кластера
uPrev[i][j]=u[i][j];
else
break;

}
return u;
}
</source>

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

Последовательная сложность всего алгоритма складывается из сложности операций на каждой итерации умноженную на количество итераций. Так как в данном алгоритме количество итераций не является фиксированным и зависит от:
* параметра <math>\varepsilon</math>
* набора входных векторов <math>x</math>
* выбора начальных коэффициентов <math>u</math>
то в данном пункте будет приведена сложность одной итерации относительно количества входных векторов.
Как видно из предыдущего пункта, для вычисления центров кластеров требуется <math>O(2*C*|X|)</math> операций, для определения коэффициентов <math>u</math> - <math>O(C^2*|X|)</math> операций, а для вычисления решающей функции - <math>O(2*C*|X|)</math> операций, где <math>|X|</math> - число входных векторов, а <math>C</math> - количество кластеров.

Таким образом итоговая сложность одной итерации составляет <math>O(C^2*|X|)</math>.

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

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

[[File:FCMIG.png|thumb|center|1200px|Рисунок 1. Информационный граф алгоритма. (1)-(7) - это наборы последовательных действий (например, (2) - последовательные операции деления, взятия адреса и присваивания).]]

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

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

Сложность алгоритма будем рассчитывать в предположении, что число вычислительных ядер стремится к бесконечности. Как видно из информационного графа, параллельная сложность вычисления центров кластеров составляет <math>O(\log_{2} C*|X|)</math>, вычисления коэффициентов принадлежности - <math>O(\log_{2} C^2*|X|)</math>, а вычисления решающей функции - не больше чем <math>O(\log_{2} C*|X|)</math>.

Таким образом параллельная сложность итерации алгоритма составляет <math>O(\log_{2} C^4*|X|^3)</math>.

Так как задачи, решаемые в макроструктуре алгоритма могут быть сведены к задачам вычисления суммы элементов массива и максимального элемента массива, то на <math>i</math>-ом ярусе графа будет находиться <math>{N}\over{2^i}</math> операции, где N - количество элементов массива.

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

==== Входные данные алгоритма ====
* <math>X</math> - набор из <math>|X|</math> входных векторов длины <math>p</math>
* <math>C</math> - количество кластеров
* <math>m</math> - коэффициент неопределённости
* <math>\varepsilon > 0</math> - коэффициент, определяющий точность алгоритма.

Объем входных данных: <math>|X|*p+3</math>

==== Выходные данные алгоритма ====
* <math>u</math> - матрица принадлежности векторов кластерам

Объем выходных данных: <math>|X|*C</math>

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

Увеличение скорости работы алгоритма при распараллеливании на бесконечном количестве процессоров составляет <math>O({{C^2*|X|}\over{\log_{2} (C^4*|X|^3)}})</math>. Например, для разбиения 1000 элементов на 10 кластеров производительность параллельного алгоритма будет в 2315 раз больше, а на 20 кластеров - уже в 8477 раз.

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

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

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

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

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

Как видно из предыдущих пунктов, масштабируется данный алгоритм хорошо. С увеличением количества процессоров время работы падает, а с увеличением количества входных данных и количества кластеров - растёт. На рисунках показаны результаты запусков алгоритма на разном количестве входных данных и процессоров на Blue Gene/P. Исходных код программы можно найти здесь: https://github.com/demonsmd/superPrak
[[File:FCMvectors.png|thumb|center|1500px|Рисунок 2. Масштабируемость алгоритма. Зависимость сложности алгоритма от количества процессоров и входных данных при фиксированном количестве кластеров.]]
[[File:FCMclusters.png|thumb|center|1500px|Рисунок 3. Масштабируемость алгоритма. Зависимость сложности алгоритма от количества процессоров и кластеров при фиксированном количестве входных данных.]]

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

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

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

Существует множество реализаций данного алгоритма. Рассмотрим некоторые из них:

- Например, тут: https://habrahabr.ru/post/208496/
<ref>Нестер А. "Алгоритм нечёткой кластеризации fuzzy c-means на PHP". [html](https://habrahabr.ru/post/208496/)</ref>
приведено краткое описание алгоритма и приведена его реализация на php. В данной статье довольно подробно расписан каждый шаг алгоритма и приведён соответствующий ему фрагмент кода.

- Тут: http://num-meth.srcc.msu.ru/zhurnal/tom_2012/v13r207.html
<ref>Миниахметов Р.М., Цымблер М.Л. "Интеграция алгоритма кластеризации Fuzzy c-Means в PostgreSQL". [html](http://num-meth.srcc.msu.ru/zhurnal/tom_2012/v13r207.html)</ref>
приводится реализация алгоритма для PostgreSQL, а также прилагается скрипт внедрения алгоритма.

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

<references \>

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

2016-11-28T07:32:32Z

Coctic:

= Статья [[Нечеткий алгоритм С средних]] =
* не указан вклад каждого автора [[Участник:Coctic|Coctic]] ([[Обсуждение участника:Coctic|обсуждение]]) 12:58, 25 октября 2016 (MSK) - исправлено
:: Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 13:29, 31 октября 2016 (MSK)
* п. 1.9 не приведены оценки объема входных и выходных данных [[Участник:Coctic|Coctic]] ([[Обсуждение участника:Coctic|обсуждение]]) 12:58, 25 октября 2016 (MSK) - исправлено
:: Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 13:29, 31 октября 2016 (MSK)
* п. 2.4. Не приведена ссылка на текст исследуемой программы [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 18:28, 16 ноября 2016 (MSK)
** Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 10:32, 28 ноября 2016 (MSK)
* п. 2.4. Не указана аппаратная платформа, на которой проводилось тестирование [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 18:28, 16 ноября 2016 (MSK)
** Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 10:32, 28 ноября 2016 (MSK)
* п. 2.4. На рис. 2 и 3 подпись вертикальной оси накладывается на подписи шкалы [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 18:28, 16 ноября 2016 (MSK)
** Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 10:32, 28 ноября 2016 (MSK)
* п. 2.4. Не приведено никаких сведений о масштабируемости исследуемой программы. На рис. 2 и 3 приведены графики зависимости некоей "сложности" (какя сложность имеется в виду - не указано) от разных параметров. Как из этих графиков извлечь сведения о масштабируемости - не указано. [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 18:28, 16 ноября 2016 (MSK)
** Исправлено частично. В осях стало время в секундах, в подписях к рисункам по-прежнему непонятная "сложность". Что в итоге на рисунках - неясно. [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 10:32, 28 ноября 2016 (MSK)
* Графики на рис. 2 и 3 плохо читаются [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 10:32, 28 ноября 2016 (MSK)
* Необходимо указать характеристики программно-аппаратной платформы (какой компилятор, с какими опциями использовался, какие версии библиотек, на каких узлах проводился запуск и т.д.) [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 10:32, 28 ноября 2016 (MSK)

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

2016-11-23T10:18:17Z

Coctic:

= Статья [[Участник:Ян-Мартин Тамм/Строгий алгоритм С средних]] =
* Отсутствует указание автора [[Участник:Coctic|Coctic]] ([[Обсуждение участника:Coctic|обсуждение]]) 11:17, 25 октября 2016 (MSK)
** Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 13:58, 31 октября 2016 (MSK)
* Пропущен пункт 1.1 "общее описание алгоритма", у следующих пунктов сместилась нумерация [[Участник:Coctic|Coctic]] ([[Обсуждение участника:Coctic|обсуждение]]) 11:17, 25 октября 2016 (MSK)
** Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 13:58, 31 октября 2016 (MSK)
* п. 1.6 на рисунках приведены схема алгоритма и его блока, информационного графа не приведено [[Участник:Coctic|Coctic]] ([[Обсуждение участника:Coctic|обсуждение]]) 11:17, 25 октября 2016 (MSK)
** Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 13:58, 31 октября 2016 (MSK)
----------------------
* Названия частей 1 и 2 не соответствуют шаблону [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 13:58, 31 октября 2016 (MSK)
** Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 13:02, 8 ноября 2016 (MSK)
* В списке литературы у первой ссылки отсутствуют выходные данные, по которым можно однозначно идентифицировать источник [[Участник:Coctic|Coctic]] ([[Обсуждение участника:Coctic|обсуждение]]) 11:17, 25 октября 2016 (MSK)
** Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 13:02, 8 ноября 2016 (MSK)
* Отсутствует п. 2.4. [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 16:55, 16 ноября 2016 (MSK)
** Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 14:15, 18 ноября 2016 (MSK)
* П. 2.4. Необходимо добавить описание ключей компилятора, особенностей запуска (раздел, используемые вычислительные узлы и т.п. информация, достаточная для воспроизведения данных). [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 14:15, 18 ноября 2016 (MSK)
** Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 13:18, 23 ноября 2016 (MSK)

Участник:Ян-Мартин Тамм/Строгий алгоритм С средних

2016-11-23T10:18:00Z

Coctic:

{{Assignment|{{REVISIONUSER}}}}
{{algorithm
| name = Строгий алгоритм С средних (K-means, Hard C-Means)
| serial_complexity = <math>O(nkdi)</math>
| pf_height = <math>O(log_2(k)log_2(d)i)</math>
| pf_width = <math>O(nkd)</math>
| input_data = <math>nd+1</math>
| output_data = <math>nk</math>
}}
Автор: [[Участник:Darel|Ян-Мартин Тамм]]

= Свойства и структура алгоритма =
== Общее описание алгоритма ==
Строгий алгоритм C средних, более известный как K-средних, решает задачу разделения векторов в многомерном пространстве на заданное количество кластеров. При этом каждый вектор принадлежит только одному кластеру, поэтому алгоритм называется строгим, в то время как нечеткий алгоритм C средних (Fuzzy C-means, Soft K-means) определяет степень принадлежности вектора каждому из кластеров.
 
Данная задача является NP-трудной, тем не менее описываемый алгоритм сходится к локальному оптимуму. Глобальный оптимум не гарантируется и зависит от первоначального распределения центров кластеров и их количества. Общая идея алгоритма такова: фиксируем число кластеров <math>k</math>, произвольным образом выбираем центры кластеров, после чего повторяем следующие два действия, пока не будет выполнено условие остановки:
#Распределяем каждый вектор в ближайший кластер
#Пересчитываем значения центров как среднее значение координат векторов в каждом кластере
Минимизируется сумма расстояний векторов от центров их кластеров. Остановка производится если либо значение данной функции становится ниже некоторого порога, либо мало изменяется по сравнению с предыдущей итерацией.
== Математическое описание алгоритма ==
Дано множество d-мерных векторов  <math>U=\{u_1, u_2, ..., u_n\}</math> и число кластеров <math>k \in \mathbb{N}</math>. Требуется разбить множество <math>U</math> на <math>k</math> непересекающихся непустых кластеров <math>C_1, C_2, ..., C_k</math> таких, что <math>{\bigcup \limits _{i = 1}^k C_i} = U </math>.
 Для этого минимизируется функция <math>
J = \sum\limits_{i=1}^k J_i = \sum\limits_{i=1}^k \sum\limits_{ u \in C_i} \|u-c_i \|^2
</math>, где <math>c_i</math>— центр масс векторов кластера <math>C_i</math>. 
Произвольным образом инициализируем центры кластеров <math>c_1, c_2, ..., c_k</math>, после чего начинается основная часть алгоритма. 
<ul><li>Каждый вектор <math>u_l</math> определяем в ближайший к нему кластер <math>C_i</math>, то есть такой, что
<math>
\|u_l-c_i\|^2 \leqslant \|u_l-c_j\|^2 \;\; \forall i \neq j; \;\; (i,j=1,2,\ldots,k, \; l = 1,2,\ldots,n)
</math>.</li> Хранить информацию о принадлежности векторов кластерам будем в матрице <math>M</math> следующего вида:
:<math>
m_{ij} = \begin{cases}
1, & u_j \in C_i \\
0, & \text{otherwise}
\end{cases}
</math>
<li>Считаем значение функции <math>J</math> и прекращаем работу алгоритма, если это значение меньше заданного порога <math>\varepsilon</math>, либо значение мало изменилось после текущей итерации.</li>
<li>Обновляем значения центров кластеров
:<math>
c_i = \frac{1}{|C_i|} \sum\limits_{u \in C_i} u \;\; (i=1,2,\ldots,k)
</math></li>
<li>Возвращаемся к распределению векторов по кластерам.</li>
</ul>

== Вычислительное ядро алгоритма ==
Вычислительным ядром алгоритма является весь алгоритм, а именно два основных его шага:
<ul><li>Распределение векторов по кластерам</li><li>Пересчёт центров кластеров</li></ul>

== Макроструктура алгоритма ==
Как уже говорилось раньше, первоначальное распределение векторов по кластерам может быть произвольным, например, можно случайным образом выбрать <math>k</math> векторов из множества всех векторов <math>U</math>. 
Далее начинается цикл, его первая операция — распределение векторов по кластерам. В ней для каждого вектора считается расстояние от него, до каждого кластера <math>\rho = \big \| u - c \big \|^2=\sum_{i=1}^d (u_i-c_i)^2</math>, после чего из них выбирается наименьшее и заносится в матрицу. Подсчёт функции <math>J</math> можно проводить одновременно с первым шагом, так как в ней суммируются те же самые расстояния. Пересчёт центров кластеров — сумма всех векторов кластера, делённая на количество объектов в кластере. <math>
c = \frac{1}{|C|} \sum\limits_{u \in C} u
</math>

== Схема реализации последовательного алгоритма ==
<source lang="python">
def kmeans(points, k, cutoff):

# Pick out k random points to use as our initial centroids
initial = random.sample(points, k)

# Create k clusters using those centroids
clusters = [Cluster([p]) for p in initial]

# Loop through the dataset until the clusters stabilize
while True:
# Create a list of lists to hold the points in each cluster
lists = [ [] for c in clusters]

# For every point in the dataset ...
for p in points:
# Get the distance between that point and the centroid of the first cluster.
smallest_distance = getDistance(p, clusters[0].centroid)

# Set the cluster this point belongs to
clusterIndex = 0

# For the remainder of the clusters ...
for i in range(clusterCount - 1):
# calculate the distance of that point to each other cluster's centroid
distance = getDistance(p, clusters[i+1].centroid)
# If it's closer to that cluster's centroid update what we
# think the smallest distance is, and set the point to belong to that cluster
if distance < smallest_distance:
smallest_distance = distance
clusterIndex = i+1
lists[clusterIndex].append(p)

# Set our total_shift to zero for this iteration
total_shift = 0.0

# As many times as there are clusters ...
for i in range(k):
# Calculate how far the centroid moved in this iteration
shift = clusters[i].update(lists[i])
# Keep track of the total moves from all cluster centroid updates
total_shift += shift

# If the centroids have stopped moving much, we're done!
if total_shift < cutoff:
break
return clusters
</source>

== Последовательная сложность алгоритма ==
Распределение по кластерам — для каждого из <math>n</math> векторов и каждого из <math>k</math> кластеров посчитать расстояние, сложив <math>d</math> раз значения, на вычисление каждого из которых нужно 2 операции — <math>O(nkd)</math>. Пересчёт центров — <math>n</math> раз сложить и <math>k</math> раз поделить —  <math>O(n+k)</math>. На завершение алгоритма понадобится <math>i</math> итераций. Итого сложность <math>O(nkdi)</math>.

== Информационный граф ==
На рисунке ниже приведён информационный граф алгоритма. 
[[Файл:HCM graph1.png]]
 
Блок, определяющий ближайший кластер, подробнее. 
[[Файл:HCM_dist1.png]]

== Ресурс параллелизма алгоритма ==
Самой трудоёмкой операцией является распределение по кластерам. Так, для рассчёта расстояний, можно провести суммирование <math>d</math> элементов за <math>log_2(d)</math> операций. Расстояние от данного вектора до всех кластеров можно найти за одну операцию, после чего нужно найти наименьшее значение из <math>k</math> элементов за <math>log_2(k)</math> операций. И всё это нужно сделать для <math>n</math> векторов, что можно сделать параллельно за одну операцию. Для сходимости всё так же потребуется <math>i</math> итераций, общая сложность получается <math>O(log_2(k)log_2(d)i)</math>.

== Входные и выходные данные алгоритма ==
'''Входные данные:'''
*<math>U=\{u_1, u_2, ..., u_n\} \subset \mathbb{R}^d</math> — множество векторов
*<math>k \in \mathbb{N}</math> — количество кластеров
*<math>\varepsilon</math> — порог остановки ''(не обязательно)''.

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

'''Выходные данные:'''
*<math>M</math> — матрица принадлежности векторов кластерам размера <math>nk</math>. При этом данная матрица содержит только <math>n</math> единиц, остальные значения ноль. Возможен вывод в другом виде, например, список списков.

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

== Свойства алгоритма ==
<ul><li>Алгоритм не является детерминированным, так как инициализация кластеров происходит случайным образом, однако, ничто не мешает проводить инициализацию согласно некоторому детерминированному правилу.
</li><li>Алгоритм находит локальный оптимум, поэтому его обычно запускают несколько раз и выбирают лучший результат.</li><li>Вычислительная мощность <math>\frac{kdi}{k+d}</math></li><li>Алгоритм является устойчивым при одинаковой первоначальной инициализации — малая ошибка в начальных данных или при вычислениях очень незначительно повлияют на результат (скорее всего никак не повлияют). Тем не менее, при случайной инициализации результаты будут различны.</li><li>Прост в реализации и вычислениях</li></ul>

= Программная реализация алгоритма =
== Особенности реализации последовательного алгоритма ==
== Локальность данных и вычислений ==
== Возможные способы и особенности параллельной реализации алгоритма ==
== Масштабируемость алгоритма и его реализации ==
Для масштабируемости использовалась следующая [http://users.eecs.northwestern.edu/~wkliao/Kmeans/index.html параллельная реализация алгоритма] с использованием MPI. Тесты были проведены на компьютерной системе [http://hpc.cmc.msu.ru/bgp BlueGene], которая включает в себя 8192 процессорных ядра и имеет пиковую производительность 27.9 терафлопс.

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

Компилятор mpicc, опция -O2. Исследуемые точки: для 1024, 2048, 4096, 8192, 16384, 32768 векторов программа запускалась на 1, 2, 4, 8, 16, 32, 64, 128, 256 ядрах. Режим исполнения по умолчанию – SMP-режим, на каждый вычислительный узел один mpi процесс.

[[Файл:HCM_BlueGene.png]]

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

= Литература =
<ol><li>[http://faculty.petra.ac.id/resmana/private/fuzzy/nfmod.pdf Jan Jantzen «Neurofuzzy Modelling».(Электронное издание)] Technical University of Denmark, Department of Automation, Bldg 326, DK-2800 Lyngby, DENMARK.
Tech. report no 98-H-874 (nfmod), 30 Oct 1998. </li><li>Steinhaus H. (1956). Sur la division des corps materiels en parties. Bull. Acad. Polon. Sci., C1. III vol IV: 801—804.</li><li>Lloyd S. (1957). Least square quantization in PCM’s. Bell Telephone Laboratories Paper.</li><li>MacQueen J. (1967). Some methods for classification and analysis of multivariate observations. In Proc. 5th Berkeley Symp. on Math. Statistics and Probability, pages 281—297.</li></ol>

Участник:Каледа Александр/Строгий алгоритм С средних (Hard C-Means)

2016-11-23T10:17:03Z

Coctic:

{{Assignment|{{REVISIONUSER}}}}

{{algorithm
| name = Строгий алгоритм С средних (Hard C-Means)
| serial_complexity = <math>O(n)</math>
| pf_height = <math>O(1)</math>
| pf_width = <math>O(n)</math>
| input_data = <math>nm+1</math>
| output_data = <math>(n+m)C</math>
}}

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

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

=== Общее описание алгоритма ===
'''Строгий алгоритм C средних''' ('''''Hard C-Means, HCM'''''; ''Jang, Sun and Mizutani, 1997''<ref>Jang, J.-S. R., Sun, C.-T. and Mizutani, E. (1997). Neuro-Fuzzy and Soft Computing, number
isbn 0-13-261066-3 in Matlab Curriculum Series, Prentice Hall, Upper Saddle River, NJ, USA.</ref>) один из наиболее широко используемых алгоритмов кластеризации данных<ref>[http://faculty.petra.ac.id/resmana/private/fuzzy/nfmod.pdf Jantzen J. Neurofuzzy Modelling. 1998. Электронное издание. 28 Стр.]</ref>. Алгоритм разбивает большие наборы векторов в многомерном пространстве по заранее заданному количеству кластеров (т.е. является управляемым).

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

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

Вычисления, выполняющиеся на очередной итерации алгоритма:

# Расчёт рядовой матрицы (сопоставление вектора соответствующему кластерному центру).
# Расчёт объектной функции.
# Пересчёт кластерных центров.

=== Математическое описание алгоритма ===
Исходные данные: матрица <math>U\in \mathbb{R}^{n\times m}</math>, представляющая собой набор векторов <math>\{u_i\}_{i=1}^{n}, u_i \in \mathbb{R}^m</math>; количество кластеров <math>C \in \mathbb{N}</math>.

Вычисляемые данные: набор векторов - кластерных центров <math>\{c_i\}_{i=1}^{C}, c_i \in \mathbb{R}^m</math>; матрица <math>M\in \mathbb{N}^{n\times C}</math> c информацией о разбиении объектов на кластера. Элемент <math>m_{ij}=1</math>, если <math>u_j \in C_i</math>, где <math>C_i</math> содержит все объекты <math>u</math>, принадлежащие кластеру <math>i</math>. Остальные элементы <math>m_{ij}=0</math>.

Алгоритм:

Шаг 1. Инициализация кластерных центров <math>c_i, i = 1, 2, \dots, C.</math> Это можно сделать выбрав случайным образом C векторов из входного набора <math>\{u_i\}_{i=1}^{n}</math>

Шаг 2. Вычисление рядовой матрицы M.

Матрица <math>M</math> состоит из элементов <math>M = \|m_{ik}\|</math>.

:<math>
m_{ik} = \begin{cases}
1, & \|u_k-c_i\|^2 \leqslant \|u_k-c_j\|^2 \;\; \text{for all } i \neq j; \;\; (i,j=1,2,\ldots,C; \; k = 1,2,\ldots,n)\\
0, & \text{otherwise}.
\end{cases}
</math>

Шаг 3. Расчет объектной функции:

:<math>
J = \sum\limits_{i=1}^C J_i = \sum\limits_{i=1}^C \left( \sum\limits_{k:\, u_k \in C_i} \|u_k -c_i \|^2 \right)</math>.

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

Шаг 4. Пересчет кластерных центров.

Пересчет кластерных центров выполняется в соответствии со следующим уравнением:
:<math>
c_i = \frac{1}{|C_i|} \sum\limits_{k:\, u_k \in C_i} u_k,
</math>
где <math>|C_i|</math> -- количество элементов в <math>i</math>-ом кластере.

Шаг 5. Переход на шаг 2.

Описание взято из <ref>[http://it-claim.ru/Persons/Neyskiy/Article2_Neiskiy.pdf Нейский И.М. Классификация и сравнение методов кластеризации // Интеллектуальные технологии и системы. Сборник учебно-методических работ и статей аспирантов и студентов. – М.: НОК «CLAIM», 2006. – Выпуск 8. – С. 130-142.]</ref>.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма Hard C-Means можно составить из множественных (всего их <math>nC</math>) вычислений квадратов нормы разности векторов <math>u_k</math> и кластерных центров <math>c_i</math>: <math>\|u_k-c_i\|^2</math>.

=== Макроструктура алгоритма ===
Как записано и в описании ядра алгоритма, основную часть метода составляют множественные (<math>Cn</math>) вычисления квадратов норм:

:<math>\|u_k-c_i\|^2</math>.

Также присутствуют данные вычислительные операции:

* Суммирование квадратов норм векторов:

:<math>
J = \sum\limits_{i=1}^C J_i = \sum\limits_{i=1}^C \left( \sum\limits_{k:\, u_k \in C_i} \|u_k -c_i \|^2 \right)
</math>

* Поэлементное суммирование векторов:

:<math>
c_i = \frac{1}{|C_i|} \sum\limits_{k:\, u_k \in C_i} u_k
</math>

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

<source lang="python3">
for i in range(n):
idx_min = 0
dist_min = ((u[i] - c[0]) ** 2).sum()

for j in range(1, C):
dist = ((u[i] - c[j]) ** 2).sum()
if dist < dist_min:
idx_min = j
dist_min = dist

M[i, idx_min] = 1
c_next[idx_min] += u[i]
c_next_cnt[idx_min] += 1
J += dist_min
</source>

=== Последовательная сложность алгоритма ===
Предполагаем, что предельная точность алгоритма достигаема менее, чем за <math>n</math> итераций. Иначе использование алгоритма можно считать нерациональным. Также предположим, что размерность <math>m</math> и количество кластерных центров <math>C</math> существенно меньше <math>n</math>.

Операция вычисления квадрата нормы разности векторов требует выполнения <math>m-1</math> арифметических операций сложения, <math>m</math> операций вычитания и <math>m</math> операций умножения.

Каждая итерация алгоритма требует выполнения:
* <math>nC</math> операций вычисления квадрата нормы разности векторов;
* <math>nC</math> операций сравнения квадрата нормы;
* <math>3n</math> операций сложения;

Таким образом, на каждой итерации имеем:
* <math>mnC</math> операций умножения;
* <math>(2mC + 3)n</math> арифметических операций сложения и вычитания;

В итоге имеем сложность последовательной реализации алгоритма <math>O(n)</math>.

=== Информационный граф ===
Граф алгоритма состоит из 4 видов вершин:

'''Первая''' группа вершин отмечена символом '''''M'''''. Ей соответствует вычисление минимального расстояния до кластерных центров, а также запись единицы в соответствующий столбец матрицы, обозначающей принадлежность кластерному центру:
* независимое вычисление расстояний от заданного элемента <math>u_i</math> до каждого из кластерных центров;
* последовательное сравнение полученных значений с целью отыскания максимума;
* операция записи 1 в соответствующий столбец матрицы принадлежности кластерным центрам;

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

'''Третья''' вершина помечена '''''if''''', на этом этапе происходит проверка условия достижения требуемой точности.

'''Четвертая''' соответствует операции пересчёта кластерных центров, она отмечена как '''''C'''''.

[[File:Cmeans.png|thumb|800px|center|Рисунок 1. Информационный граф алгоритма. Здесь '''''in''''' — ввод входных данных, '''''D''''' — вычисление минимального расстояния до кластерных центров и проставление принадлежности соответствующему кластерному центру, '''''J''''' — вычисление объектной функции по результатам полученных вычислений, '''''if''''' — проверка условия достижения желаемой точности, '''''C''''' — пересчёт кластерных центров и '''''out''''' — вывод полученных данных.]]

=== Ресурс параллелизма алгоритма ===
Основной ресурс параллелизма алгоритма составляет итерационный блок. Эта последовательность итераций может быть выполнена для каждого входного вектора <math>u_i</math> независимо. Однако, в конце выполнения каждого итерационного блока имеют место последовательные вычисления - сложение значений объектной функции, полученных независимо на каждом процессоре, а также перерасчет кластерных центров.

Высота [[глоссарий#Ярусно-параллельная форма графа алгоритма|ЯПФ]] оценивается как <math>O(1)</math> (при условии, что число итераций существенно меньше объёма выборки <math>n</math>). Ширина [[глоссарий#Ярусно-параллельная форма графа алгоритма|ЯПФ]] равна <math>n</math>.

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

=== Входные и выходные данные алгоритма ===
'''Входные данные:''' матрица <math>U\in \mathbb{R}^{n\times m}</math>, представляющая собой набор векторов <math>\{u_i\}_{i=1}^{n}, u_i \in \mathbb{R}^m</math>; количество кластеров <math>C \in \mathbb{N}</math>.

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

'''Выходные данные:''' набор векторов - кластерных центров <math>\{c_i\}_{i=1}^{C}, c_i \in \mathbb{R}^m</math>; матрица <math>M\in \mathbb{N}^{n\times C}</math> c информацией о разбиении объектов на кластера. Элемент <math>m_{ij}=1</math>, если <math>u_j \in C_i</math>, где <math>C_i</math> содержит все объекты <math>u</math>, принадлежащие кластеру <math>i</math>. Остальные элементы <math>m_{ij}=0</math>.

'''Объём выходных данных:''' <math>(n+m)C</math>.

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

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

Недостатки:

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

Соотношение последовательной и параллельной сложности алгоритма: линейное.

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

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

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

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

=== Масштабируемость алгоритма и его реализации ===
Проведём исследование масштабируемости параллельной реализации строгого алгоритма C средних согласно [[Scalability methodology|методике]].

Исследование проводилось на 1U сервере со '''следующими характеристиками''':
* 2 x Intel® Xeon® Processor E5-2697 v2;
* 128GB RAM;

==== Масштабируемость реализации алгоритма ====
Сборка осуществлялась со следующими параметрами:

* GCC-4.8.4;
* OpenMP-3.1;
* аргументы компилятора: -std=c++11 -O3;

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

* число процессоров [1 : 48] с шагом 1;
* размерность пространства [3 : 50] c шагом 3;
* число векторов 100 000 000;
* число кластерных центров 30;

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

* минимальная эффективность реализации 0.014;
* максимальная эффективность реализации 0.9;

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

[[file:GFLOPS_AA.png|thumb|center|700px|Рисунок 2. Параллельная реализация алгоритма. Изменение производительности в зависимости от числа процессоров и размерности векторов.]]
[[file:EFFICIENCY.png|thumb|center|700px|Рисунок 3. Параллельная реализация алгоритма. Изменение эффективности в зависимости от числа процессоров и размерности векторов.]]

==== Реализация на языке C++ ====
[http://pastebin.com/31UkHgcW Исследованная параллельная реализация на языке C++]

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

=== Существующие реализации алгоритма ===
* [http://projects.jasmeet.me/2013/03/HardCMeans.html Последовательная реализация алгоритма на MatLab]
* [https://github.com/artpar/Hard-Clustering-implementation Последовательная реализация алгоритма на С++]

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

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

2016-11-23T10:16:50Z

Coctic:

= Статья [[Участник:Каледа Александр/Строгий алгоритм С средних (Hard C-Means)]] =
* Не указан вклад каждого автора [[Участник:Coctic|Coctic]] ([[Обсуждение участника:Coctic|обсуждение]]) 11:08, 25 октября 2016 (MSK)
** Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 12:42, 2 ноября 2016 (MSK)
* Стоит добавить ссылку на оригинальную публикацию, в которой был впервые предложен алгоритм. [[Участник:Coctic|Coctic]] ([[Обсуждение участника:Coctic|обсуждение]]) 11:08, 25 октября 2016 (MSK)
** Не исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 12:42, 2 ноября 2016 (MSK)
* Значительная часть п. 1.2 совпадает с тем же пунктом из [[Строгий алгоритм С средних (Hard C-Means, HCM)]]
** Замечание снимается [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 12:42, 2 ноября 2016 (MSK)
* Пункты раздела 2 не соответствуют шаблону. П. 2.1 должен быть 2.4, п. 2.2 должен быть 2.7, остальные пункты пропущены [[Участник:Coctic|Coctic]] ([[Обсуждение участника:Coctic|обсуждение]]) 11:08, 25 октября 2016 (MSK)
** Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 12:42, 2 ноября 2016 (MSK)
* В списке литературы отсутствуют выходные данные публикаций, кроме названия и автора. По приведенным данным определить конкретную публикацию не представляется возможным. [[Участник:Coctic|Coctic]] ([[Обсуждение участника:Coctic|обсуждение]]) 11:08, 25 октября 2016 (MSK)
** Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 12:42, 2 ноября 2016 (MSK)
* Список литературы совпадает со списком из [[Строгий алгоритм С средних (Hard C-Means, HCM)]] [[Участник:Coctic|Coctic]] ([[Обсуждение участника:Coctic|обсуждение]]) 11:08, 25 октября 2016 (MSK)
** Замечание снимается [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 12:42, 2 ноября 2016 (MSK)

------------
* Стоит добавить ссылку на оригинальную публикацию, в которой был впервые предложен алгоритм [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 12:42, 2 ноября 2016 (MSK)
** Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 13:16, 23 ноября 2016 (MSK)
* п. 2.4.1 пустой. [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 10:35, 17 ноября 2016 (MSK)
** Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 13:16, 23 ноября 2016 (MSK)
* п. 2.4.2. Отсутствует ссылка на текст исследуемой программы и аппаратную платформу, на которой проводилось тестирование. [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 10:35, 17 ноября 2016 (MSK)
** Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 13:16, 23 ноября 2016 (MSK)
* Рис. 3. В подписи к рисунку не указано, график зависимости эффективности какого типа приведен. [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 10:35, 17 ноября 2016 (MSK)
** Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 13:16, 23 ноября 2016 (MSK)

Участник:Светлана Лукьяненко/Строгий алгоритм С средних (Hard C-Means, HCM)

2016-11-23T10:15:05Z

Coctic:

{{assignment|{{REVISIONUSER}}}}

{{algorithm
| name = Строгий алгоритм С средних (Hard C-Means,HCM)
| serial_complexity = <math>O(N)</math>
| pf_height = <math>O(1)</math>
| pf_width = <math>O(N)</math>
| input_data = <math>nN+1</math>
| output_data = <math>C(N+n)</math>
}}

Авторы описания: [[Участник:Светлана_Лукьяненко|Лукьяненко Светлана]](1.1, 1.3, 1.4, 1.8, 1.10, 2.4, 2.7), [[Участник:Юрий_Комаров|Комаров Юрий]](1.2, 1.5, 1.6, 1.7, 1.8, 1.9, 2.4)

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

=== Общее описание алгоритма ===
'''Строгий алгоритм C средних''' ('''''Hard C-Means'''''; ''Jang, Sun and Mizutani, 1997''<ref>Jang, J.-S. R., Sun, C.-T. and Mizutani, E. (1997). Neuro-Fuzzy and Soft Computing, number
isbn 0-13-261066-3 in Matlab Curriculum Series, Prentice Hall, Upper Saddle River, NJ, USA.</ref>) позволяет распределить большие наборы числовых данных по кластерам в многомерном пространстве<ref>Jan Jantzen (1998). [http://faculty.petra.ac.id/resmana/private/fuzzy/nfmod.pdf Neurofuzzy Modelling.]</ref>. Алгоритм является управляемым, так как для работы с ним требуется задание одного параметра — числа кластеров, на которое необходимо разделить данные.
Входными данными для алгоритма являются набор векторов и количество кластеров, также может задаваться пороговое значение величины объектной функции, по достижении которого расчёт прекращается. Выходными данными для алгоритма является рядовая матрица, отображающая принадлежность исходных элементов построенным кластерам, и центры построенных кластеров.

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

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

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

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

==== Входные и выходные данные ====
На вход подаётся набор векторов <math>\{u_k\}_{k=1}^{N}</math> пространства <math>\mathbb{R}^n</math> и количество кластеров <math>C</math>.

Конечным результатом работы алгоритма являются построенная рядовая матрица <math>M</math>, содержащая информацию о принадлежности элементов кластерам:
:<math>
m_{ij} = \begin{cases}
1, & u_j \in C_i, \\
0, & \text{otherwise},
\end{cases}
</math>
где под <math>C_i</math> подразумевается <math>i</math>-ый построенный кластер, и набор <math>\{c_i\}_{i=1}^{C}</math> центров этих кластеров.

==== Описание алгоритма ====
Алгоритм состоит из 5 последовательных шагов.<ref>Нейский И. М. [http://it-claim.ru/Persons/Neyskiy/Article2_Neiskiy.pdf Классификация и сравнение методов кластеризации.] // Интеллектуальные технологии и системы. Сборник учебно-методических работ и статей аспирантов и студентов. – М.: НОК «CLAIM», 2006. – Выпуск 8. – С. 130-142.</ref>

'''Шаг 1'''

'''Инициализация кластерных центров''' <math>c_i \, (i=1,2,\ldots,C)</math> может происходить за счёт случайного выбора необходимого числа точек из входного набора либо путём явного указания.

'''Шаг 2'''

'''Вычисление рядовой матрицы''' <math>M = \|m_{ik}\|</math>, элементы которой задаются следующими выражениями (<math>N</math> — количество элементов во входном наборе данных):
:<math>
m_{ik} = \begin{cases}
1, & \|u_k-c_i\|^2 \leqslant \|u_k-c_j\|^2 \;\; \text{for all } i \neq j; \;\; (i,j=1,2,\ldots,C; \; k = 1,2,\ldots,N)\\
0, & \text{otherwise}.
\end{cases}
</math>


Будем говорить, что <math>u_k \in C_i</math>, если <math>m_{ik} = 1</math>.

'''Шаг 3'''

'''Расчёт объектной функции:'''
:<math>
J = \sum\limits_{i=1}^C J_i = \sum\limits_{i=1}^C \left( \sum\limits_{k:\, u_k \in C_i} \|u_k -c_i \|^2 \right)
.</math>

На этом шаге происходит '''остановка и выход из цикла''', если полученное значение ниже пороговой величины <math>\varepsilon_{tr}</math> или полученное значение не сильно отличается от значений, полученных на предыдущих циклах.

'''Шаг 4'''

'''Пересчёт кластерных центров''' выполняется в соответствии со следующим уравнением:
:<math>
c_i = \frac{1}{|C_i|} \sum\limits_{k:\, u_k \in C_i} u_k,
</math>
где под <math>|C_i|</math> подразумевается количество элементов в <math>i</math>-ом кластере.

'''Шаг 5'''

'''Переход по циклу''' на шаг 2.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма составляют вычисления квадратов нормы расстояния от каждого из векторов исходной выборки до промежуточных кластерных центров <math>\|u_k-c_i\|^2</math>. На каждой итерации алгоритма происходит расчёт <math>CN</math> таких расстояний.

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

<math>
d_{ki} = \|u_k-c_i\|^2
</math>

Также на шаге вычисления объектной функции производится множественное суммирование полученных расстояний:

<math>
J = \sum\limits_{i=1}^C J_i = \sum\limits_{i=1}^C \left( \sum\limits_{k:\, u_k \in C_i} \|u_k -c_i \|^2 \right),
</math>

а на шаге расчета кластерных центров происходит суммирование векторов:

<math>
c_i = \frac{1}{|C_i|} \sum\limits_{k:\, u_k \in C_i} u_k.
</math>

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

<source lang="pascal">
J = 0;
M = zeros(N,C);
for i = 1 to N //go through every element
d_min = MAXINT;
j_min = 1;
for j = 1 to C //deside which claster does element belong to
d_ij = sq_norm(u[i] - c[j]);
if d_ij < d_min
d_min = d_ij;
j_min = j;
//generation of output data
J += d_min;
M[i,j_min] = 1;
c_new[j] += u[i];
c_newCount[k]++;

</source>

=== Последовательная сложность алгоритма ===
На каждой итерации алгоритма требуется выполнение:
* <math>NC</math> операций вычисления квадрата нормы разности элементов;
* <math>NC</math> операций сравнения (вычитаний);
* <math>3N</math> операций сложения.

Каждая операция вычисления нормы разности векторов предполагает выполнение <math>2n-1</math> арифметических операций сложения и вычитания и <math>n</math> операций возведения в квадрат (умножений), поэтому получаем для каждой итерации:
* <math>(2nC + 3)N</math> арифметических операций сложения и вычитания;
* <math>nNC</math> операций умножения.

Ожидая, что предельная точность будет достигнута менее, чем за <math>N</math> итераций (в противном случае применение алгоритма можно считать нецелесообразным), получаем итоговую сложность последовательной реализации алгоритма <math>O(N)</math> (в предположении, что <math>n</math> и <math>C</math> существенно меньше <math>N</math>).

=== Информационный граф ===
Приведём аналитическое и графическое описание графа алгоритма.

Граф алгоритма состоит из 5 различных видов вершин.

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

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

'''Третья''' вершина отмечена символом '''''J''''', подразумевается, что на этом этапе происходит расчёт объектной функции.

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

'''Пятая''' соответствует операции пересчёта кластерных центров, она отмечена как '''''{c}'''''.

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

[[File:HardCMeans1.png|thumb|800px|center|Рисунок 1. Информационный граф алгоритма. Здесь '''''in''''' — ввод входных данных (<math>C</math> стартовых значений кластерных центров и 1 значение <math>u_i</math> на каждую вершину графа), '''''d''''' — вычисление минимального расстояния до кластерных центров (подробнее см. рисунок 2), '''''M''''' — запись единички в соответствующий столбец матрицы <math>M</math>, '''''J''''' — вычисление объектной функции по результатам полученных вычислений, '''''if''''' — проверка условия достижения заданной точности, '''''{c}''''' — пересчёт кластерных центров и '''''out''''' — вывод полученных данных (матрица <math>M</math> и <math>C</math> значений полученных кластерных центров).]]
[[File:HardCMeans2.PNG|thumb|400px|center|Рисунок 2. Подробное описание работы блока '''''d'''''. Здесь '''''in''''' — ввод входных данных (по 1 значению центра кластера на каждую из <math>C</math> соответствующих вершин графа и значение <math>u_i</math>, единое для этого '''''d'''''-блока), '''''d1,...,dC''''' — прямое вычисление расстояния до кластерных центров, '''''min''''' — вычисление минимума двух чисел (с сохранением соответствующего минимуму кластерного индекса) и '''''out''''' — вывод полученных данных (индекс кластерного центра, расположенного ближе всего к точке <math>u_i</math>, и соответствующее расстояние).]]

=== Ресурс параллелизма алгоритма ===
Для выполнения одной итерации алгоритма C средних необходимо выполнить параллельно ряд вычислений для каждого из <math>N</math> элементов:

# Вычисление <math>C</math> расстояний между элементом и кластерными центрами.
# Выполнение <math>(C - 1)</math> сравнений для определения минимального.
# Определение значений соответствующего рассматриваемому элементу <math>u_i</math> столбца матрицы <math>M</math>.

Эта последовательность операций может быть выполнена для каждого элемента <math>u_i</math> входной выборки независимо и поэтому составляет основной ресурс параллелизма алгоритма.

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

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

При этом, как легко видеть, ширина [[глоссарий#Ярусно-параллельная форма графа алгоритма|ЯПФ]] составляет <math>O(N)</math> (если быть точнее, просто <math>N</math>). Высота ЯПФ для строгого алгоритма C средних оценивается как <math>O(1)</math> (предполагаем, что число итераций существенно меньше объёма выборки <math>N</math>).

=== Входные и выходные данные алгоритма ===
'''Входные данные:'''
*<math>\{u_k\}_{k=1}^{N} \subset \mathbb{R}^n</math> — исходный набор векторов;
*<math>C</math> — количество кластеров (<math>2 \leqslant C \leqslant N</math>);
* ''(опционально)'' <math>\varepsilon_{tr}</math> — пороговая точность работы алгоритма.

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

'''Выходные данные:'''
*<math>M</math> — рядовая матрица из пространства <math>\mathbb{R}^{C \times N}</math>.
*<math>\{c_k\}_{k=1}^{C}</math> — набор построенных кластерных центров.

'''Объём выходных данных:''' <math>C(N+n)</math>.

=== Свойства алгоритма ===
'''Назначение:''' кластеризация больших наборов числовых данных.

'''Достоинства:'''
* лёгкость реализации;
* вычислительная простота.

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

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
==== Локальность реализации алгоритма ====
===== Структура обращений в память и качественная оценка локальности =====
===== Количественная оценка локальности =====
=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===
Исследуем масштабируемость параллельной реализации строгого алгоритма C средних, соответствующей последовательной реализации, описанной в [[#Схема реализации последовательного алгоритма|п1.5]]. Для проведения расчётов использовались ресурсы вычислительного комплекса [http://hpc.cmc.msu.ru/bgp IBM Blue Gene/P] и [https://github.com/ykomarov94/AlgoWiki собственная реализация алгоритма].

Основные характеристики реализации алгоритма и запуска программы:
* программа написана на языке C с использованием [http://hpc.cmc.msu.ru/bgp/development/parallel библиотеки MPI];
* сборка программы произведена с использованием компилятора [http://hpc.cmc.msu.ru/bgp/development/compilers IBM XL C Advanced Edition for Blue Gene/P V9.0] версии 9.0.0.0005;
* при компиляции не использовались дополнительные опции;
* при тестировании использовались псевдослучайные наборы векторов заданной размерности;
* для каждой конфигурации проводилась серия экспериментов, после чего для получения конечных результатов производительности проводилось усреднение.

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

* число процессоров <math>[16 : 256]</math> с шагом по степеням двойки;
* объём выборки <math>[10^3:10^7]</math> с шагом по степеням десятки;
* размерность системы <math>n=10</math>;
* количество кластеров <math>C = 11</math>.

В качестве изменяемого параметра для построения графика был выбран объём выборки <math>N</math>, поскольку варьирование прочих параметров существенно хуже отражает возможности применения технологии параллельных вычислений. Это связано с тем, что при малом количестве векторов время, затраченное на пересылку данных, сравнимо со временем, затрачиваемым непосредственно на расчёты; это хорошо видно на графике: при объёмах выборки, составляющих <math>10^3</math> и <math>10^4</math> векторов, использование большего числа процессоров не приводит к приросту производительности (наоборот, производительность падает) ввиду высоких накладных расходов.

[[file:HardCMeansPerfomance.png|thumb|center|700px|Рис.3 Реализация строгого алгоритма C средних. График производительности (GFLOPS) в зависимости от числа процессоров и объёма выборки.]]

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

1) [https://github.com/artpar/Hard-Clustering-implementation Последовательная реализация на С++ ]

2) [http://projects.jasmeet.me/2013/03/HardCMeans.html Последовательная реализация на MatLab ]

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

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

Обсуждение участника:Светлана Лукьяненко

2016-11-23T10:14:36Z

Coctic:

= Статья [[Участник:Светлана Лукьяненко/Строгий алгоритм С средних (Hard C-Means, HCM)]] =
* Не указан вклад каждого автора [[Участник:Coctic|Coctic]] ([[Обсуждение участника:Coctic|обсуждение]]) 10:57, 25 октября 2016 (MSK)
** Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 15:05, 31 октября 2016 (MSK)
* Значительная часть п. 1.2 совпадает с тем же пунктом из [[Участник:Каледа Александр/Строгий алгоритм С средних (Hard C-Means)]] [[Участник:Coctic|Coctic]] ([[Обсуждение участника:Coctic|обсуждение]]) 11:05, 25 октября 2016 (MSK)
** Замечание снимается [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 15:05, 31 октября 2016 (MSK)
* В списке литературы отсутствуют выходные данные публикаций, кроме названия и автора. По приведенным данным определить конкретную публикацию не представляется возможным. Стоит добавить ссылку на оригинальную публикацию с описанием алгоритма, упомянутую в начале п.1.1 [[Участник:Coctic|Coctic]] ([[Обсуждение участника:Coctic|обсуждение]]) 10:57, 25 октября 2016 (MSK)
** Не исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 15:05, 31 октября 2016 (MSK)
* Список литературы совпадает со списком из [[Участник:Каледа Александр/Строгий алгоритм С средних (Hard C-Means)]] [[Участник:Coctic|Coctic]] ([[Обсуждение участника:Coctic|обсуждение]]) 11:01, 25 октября 2016 (MSK)
** Замечание снимается [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 15:05, 31 октября 2016 (MSK)
----------------------
* Комментарий от [[Участник:Юрий Комаров|Комарова Юрия]]: Сравните, пожалуйста, нашу историю работы над статьёй с историей работы над статьёй наших коллег: Каледы и его товарища. Сделав это, Вы обнаружите, что мы начали работать сразу же после выдачи задания, практически одними из первых и гораздо раньше указанных ребят, и неоднократно правили каждый из пунктов, доводя их до лучшей кондиции. За то, что пункт 1.2, как, впрочем, и другие пункты, и список литературы были составлены нами лично в процессе длительной совместной работы со [[Участник:Светлана Лукьяненко|Светланой]], отвечаю головой. Надеюсь, вопрос о плагиате больше не возникнет. В такой ситуации исправлять что-то должны явно не мы. С уважением, Комаров Юрий.
** В мои задачи не входить обвинять кого-то в плагиате, проводить расследования, кто у кого списал, или выяснять, кто прав, а кто нет. Меня попросили проверить статью, обращая внимание на пересечения с другими на ту же тему. В двух статьях есть общая часть, это пошло в замечания к обеим статьям. Пересечение уйдет - замечание снимется. Кто исправит текст - мне все равно. Когда в статье появится метка, что ее можно снова проверять - я сравню тексты снова. Пока текст совпадает - замечание с моей стороны остается. Есть А.С. Антонов, если он сочтет, что это замечание можно проигнорировать (в одной статье или в обеих) - он продвинет статью дальше. [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 18:31, 28 октября 2016 (MSK)
** Если говорить о, скажем мягко, некорректном заимствовании, то ваш п 1.2 есть воспроизведение фрагмента из работы Нейского с небольшими добавлениями. У вас имеется разрешение автора на такое воспроизведение? Так что не стоит так сразу головой-то... [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 18:31, 28 октября 2016 (MSK)
** В общем, не стоит отвечать в таком тоне. Я могу понять возмущение, но писать надо корректнее. [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 18:31, 28 октября 2016 (MSK)
* Вклад авторов указан, в источниках приведены ссылки. Исправлять часть статьи, которую у нас украли наши коллеги (дата создания их страницы 15 октября), должны не мы, а указанные личности. К сожалению, заставить их это сделать мы не можем, полагаю, регулирование этого вопроса нам разумнее доверить проверяющим.

-----
* В списке литературы отсутствуют выходные данные публикаций, кроме названия и автора. По приведенным данным определить конкретную публикацию не представляется возможным. Стоит добавить ссылку на оригинальную публикацию с описанием алгоритма, упомянутую в начале п.1.1 [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 15:05, 31 октября 2016 (MSK)
** Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 11:06, 3 ноября 2016 (MSK)

----
* п. 2.4. Не приведена ссылка на текст анализируемой программы. [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 10:38, 17 ноября 2016 (MSK)
** Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 15:28, 22 ноября 2016 (MSK)
* Необходимо указать характеристики программно-аппаратной платформы (какой компилятор, с какими опциями использовался, какие версии библиотек, на каких узлах проводился запуск и т.д.) [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 15:28, 22 ноября 2016 (MSK)
** Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 13:14, 23 ноября 2016 (MSK)
* В подписи к рис. 3 указано, что это ''График производительности ... от числа параллельных процессов'', а подписи к оси указано, что по ней отложено число процессоров (Processors). Какой вариант правильный? [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 15:28, 22 ноября 2016 (MSK)
** Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 13:14, 23 ноября 2016 (MSK)

Участник:Светлана Лукьяненко/Строгий алгоритм С средних (Hard C-Means, HCM)

2016-11-22T12:28:45Z

Coctic:

{{algorithm
| name = Строгий алгоритм С средних (Hard C-Means,HCM)
| serial_complexity = <math>O(N)</math>
| pf_height = <math>O(1)</math>
| pf_width = <math>O(N)</math>
| input_data = <math>nN+1</math>
| output_data = <math>C(N+n)</math>
}}

Авторы описания: [[Участник:Светлана_Лукьяненко|Лукьяненко Светлана]](1.1, 1.3, 1.4, 1.8, 1.10, 2.4, 2.7), [[Участник:Юрий_Комаров|Комаров Юрий]](1.2, 1.5, 1.6, 1.7, 1.8, 1.9, 2.4)

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

=== Общее описание алгоритма ===
'''Строгий алгоритм C средних''' ('''''Hard C-Means'''''; ''Jang, Sun and Mizutani, 1997''<ref>Jang, J.-S. R., Sun, C.-T. and Mizutani, E. (1997). Neuro-Fuzzy and Soft Computing, number
isbn 0-13-261066-3 in Matlab Curriculum Series, Prentice Hall, Upper Saddle River, NJ, USA.</ref>) позволяет распределить большие наборы числовых данных по кластерам в многомерном пространстве<ref>Jan Jantzen (1998). [http://faculty.petra.ac.id/resmana/private/fuzzy/nfmod.pdf Neurofuzzy Modelling.]</ref>. Алгоритм является управляемым, так как для работы с ним требуется задание одного параметра — числа кластеров, на которое необходимо разделить данные.
Входными данными для алгоритма являются набор векторов и количество кластеров, также может задаваться пороговое значение величины объектной функции, по достижении которого расчёт прекращается. Выходными данными для алгоритма является рядовая матрица, отображающая принадлежность исходных элементов построенным кластерам, и центры построенных кластеров.

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

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

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

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

==== Входные и выходные данные ====
На вход подаётся набор векторов <math>\{u_k\}_{k=1}^{N}</math> пространства <math>\mathbb{R}^n</math> и количество кластеров <math>C</math>.

Конечным результатом работы алгоритма являются построенная рядовая матрица <math>M</math>, содержащая информацию о принадлежности элементов кластерам:
:<math>
m_{ij} = \begin{cases}
1, & u_j \in C_i, \\
0, & \text{otherwise},
\end{cases}
</math>
где под <math>C_i</math> подразумевается <math>i</math>-ый построенный кластер, и набор <math>\{c_i\}_{i=1}^{C}</math> центров этих кластеров.

==== Описание алгоритма ====
Алгоритм состоит из 5 последовательных шагов.<ref>Нейский И. М. [http://it-claim.ru/Persons/Neyskiy/Article2_Neiskiy.pdf Классификация и сравнение методов кластеризации.] // Интеллектуальные технологии и системы. Сборник учебно-методических работ и статей аспирантов и студентов. – М.: НОК «CLAIM», 2006. – Выпуск 8. – С. 130-142.</ref>

'''Шаг 1'''

'''Инициализация кластерных центров''' <math>c_i \, (i=1,2,\ldots,C)</math> может происходить за счёт случайного выбора необходимого числа точек из входного набора либо путём явного указания.

'''Шаг 2'''

'''Вычисление рядовой матрицы''' <math>M = \|m_{ik}\|</math>, элементы которой задаются следующими выражениями (<math>N</math> — количество элементов во входном наборе данных):
:<math>
m_{ik} = \begin{cases}
1, & \|u_k-c_i\|^2 \leqslant \|u_k-c_j\|^2 \;\; \text{for all } i \neq j; \;\; (i,j=1,2,\ldots,C; \; k = 1,2,\ldots,N)\\
0, & \text{otherwise}.
\end{cases}
</math>


Будем говорить, что <math>u_k \in C_i</math>, если <math>m_{ik} = 1</math>.

'''Шаг 3'''

'''Расчёт объектной функции:'''
:<math>
J = \sum\limits_{i=1}^C J_i = \sum\limits_{i=1}^C \left( \sum\limits_{k:\, u_k \in C_i} \|u_k -c_i \|^2 \right)
.</math>

На этом шаге происходит '''остановка и выход из цикла''', если полученное значение ниже пороговой величины <math>\varepsilon_{tr}</math> или полученное значение не сильно отличается от значений, полученных на предыдущих циклах.

'''Шаг 4'''

'''Пересчёт кластерных центров''' выполняется в соответствии со следующим уравнением:
:<math>
c_i = \frac{1}{|C_i|} \sum\limits_{k:\, u_k \in C_i} u_k,
</math>
где под <math>|C_i|</math> подразумевается количество элементов в <math>i</math>-ом кластере.

'''Шаг 5'''

'''Переход по циклу''' на шаг 2.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма составляют вычисления квадратов нормы расстояния от каждого из векторов исходной выборки до промежуточных кластерных центров <math>\|u_k-c_i\|^2</math>. На каждой итерации алгоритма происходит расчёт <math>CN</math> таких расстояний.

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

<math>
d_{ki} = \|u_k-c_i\|^2
</math>

Также на шаге вычисления объектной функции производится множественное суммирование полученных расстояний:

<math>
J = \sum\limits_{i=1}^C J_i = \sum\limits_{i=1}^C \left( \sum\limits_{k:\, u_k \in C_i} \|u_k -c_i \|^2 \right),
</math>

а на шаге расчета кластерных центров происходит суммирование векторов:

<math>
c_i = \frac{1}{|C_i|} \sum\limits_{k:\, u_k \in C_i} u_k.
</math>

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

<source lang="pascal">
J = 0;
M = zeros(N,C);
for i = 1 to N //go through every element
d_min = MAXINT;
j_min = 1;
for j = 1 to C //deside which claster does element belong to
d_ij = sq_norm(u[i] - c[j]);
if d_ij < d_min
d_min = d_ij;
j_min = j;
//generation of output data
J += d_min;
M[i,j_min] = 1;
c_new[j] += u[i];
c_newCount[k]++;

</source>

=== Последовательная сложность алгоритма ===
На каждой итерации алгоритма требуется выполнение:
* <math>NC</math> операций вычисления квадрата нормы разности элементов;
* <math>NC</math> операций сравнения (вычитаний);
* <math>3N</math> операций сложения.

Каждая операция вычисления нормы разности векторов предполагает выполнение <math>2n-1</math> арифметических операций сложения и вычитания и <math>n</math> операций возведения в квадрат (умножений), поэтому получаем для каждой итерации:
* <math>(2nC + 3)N</math> арифметических операций сложения и вычитания;
* <math>nNC</math> операций умножения.

Ожидая, что предельная точность будет достигнута менее, чем за <math>N</math> итераций (в противном случае применение алгоритма можно считать нецелесообразным), получаем итоговую сложность последовательной реализации алгоритма <math>O(N)</math> (в предположении, что <math>n</math> и <math>C</math> существенно меньше <math>N</math>).

=== Информационный граф ===
Приведём аналитическое и графическое описание графа алгоритма.

Граф алгоритма состоит из 5 различных видов вершин.

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

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

'''Третья''' вершина отмечена символом '''''J''''', подразумевается, что на этом этапе происходит расчёт объектной функции.

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

'''Пятая''' соответствует операции пересчёта кластерных центров, она отмечена как '''''{c}'''''.

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

[[File:HardCMeans1.png|thumb|800px|center|Рисунок 1. Информационный граф алгоритма. Здесь '''''in''''' — ввод входных данных (<math>C</math> стартовых значений кластерных центров и 1 значение <math>u_i</math> на каждую вершину графа), '''''d''''' — вычисление минимального расстояния до кластерных центров (подробнее см. рисунок 2), '''''M''''' — запись единички в соответствующий столбец матрицы <math>M</math>, '''''J''''' — вычисление объектной функции по результатам полученных вычислений, '''''if''''' — проверка условия достижения заданной точности, '''''{c}''''' — пересчёт кластерных центров и '''''out''''' — вывод полученных данных (матрица <math>M</math> и <math>C</math> значений полученных кластерных центров).]]
[[File:HardCMeans2.PNG|thumb|400px|center|Рисунок 2. Подробное описание работы блока '''''d'''''. Здесь '''''in''''' — ввод входных данных (по 1 значению центра кластера на каждую из <math>C</math> соответствующих вершин графа и значение <math>u_i</math>, единое для этого '''''d'''''-блока), '''''d1,...,dC''''' — прямое вычисление расстояния до кластерных центров, '''''min''''' — вычисление минимума двух чисел (с сохранением соответствующего минимуму кластерного индекса) и '''''out''''' — вывод полученных данных (индекс кластерного центра, расположенного ближе всего к точке <math>u_i</math>, и соответствующее расстояние).]]

=== Ресурс параллелизма алгоритма ===
Для выполнения одной итерации алгоритма C средних необходимо выполнить параллельно ряд вычислений для каждого из <math>N</math> элементов:

# Вычисление <math>C</math> расстояний между элементом и кластерными центрами.
# Выполнение <math>(C - 1)</math> сравнений для определения минимального.
# Определение значений соответствующего рассматриваемому элементу <math>u_i</math> столбца матрицы <math>M</math>.

Эта последовательность операций может быть выполнена для каждого элемента <math>u_i</math> входной выборки независимо и поэтому составляет основной ресурс параллелизма алгоритма.

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

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

При этом, как легко видеть, ширина [[глоссарий#Ярусно-параллельная форма графа алгоритма|ЯПФ]] составляет <math>O(N)</math> (если быть точнее, просто <math>N</math>). Высота ЯПФ для строгого алгоритма C средних оценивается как <math>O(1)</math> (предполагаем, что число итераций существенно меньше объёма выборки <math>N</math>).

=== Входные и выходные данные алгоритма ===
'''Входные данные:'''
*<math>\{u_k\}_{k=1}^{N} \subset \mathbb{R}^n</math> — исходный набор векторов;
*<math>C</math> — количество кластеров (<math>2 \leqslant C \leqslant N</math>);
* ''(опционально)'' <math>\varepsilon_{tr}</math> — пороговая точность работы алгоритма.

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

'''Выходные данные:'''
*<math>M</math> — рядовая матрица из пространства <math>\mathbb{R}^{C \times N}</math>.
*<math>\{c_k\}_{k=1}^{C}</math> — набор построенных кластерных центров.

'''Объём выходных данных:''' <math>C(N+n)</math>.

=== Свойства алгоритма ===
'''Назначение:''' кластеризация больших наборов числовых данных.

'''Достоинства:'''
* лёгкость реализации;
* вычислительная простота.

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

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
==== Локальность реализации алгоритма ====
===== Структура обращений в память и качественная оценка локальности =====
===== Количественная оценка локальности =====
=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===
Исследуем масштабируемость параллельной реализации строгого алгоритма C средних, соответствующей последовательной реализации, описанной в [[#Схема реализации последовательного алгоритма|п1.5]]. Для проведения расчётов использовались ресурсы вычислительного комплекса IBM Blue Gene/P и [https://github.com/ykomarov94/AlgoWiki собственная реализация алгоритма], поскольку в открытом доступе параллельные реализации алгоритма авторами найдены не были ([[#Существующие реализации алгоритма|п2.7]]).

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

* число процессоров <math>[16 : 256]</math> с шагом по степеням двойки;
* объём выборки <math>[10^3:10^7]</math> с шагом по степеням десятки;
* размерность системы <math>n=10</math>;
* количество кластеров <math>C = 11</math>.

В качестве изменяемого параметра для построения графика был выбран объём выборки <math>N</math>, поскольку варьирование прочих параметров существенно хуже отражает возможности применения технологии параллельных вычислений. Это связано с тем, что при малом количестве векторов время, затраченное на пересылку данных, сравнимо со временем, затрачиваемым непосредственно на расчёты; это хорошо видно на графике: при объёмах выборки, составляющих <math>10^3</math> и <math>10^4</math> векторов, использование большего числа процессоров не приводит к приросту производительности (наоборот, производительность падает) ввиду высоких накладных расходов.

[[file:HardCMeansPerfomance.png|thumb|center|700px|Рис.3 Реализация строгого алгоритма C средних. График производительности (GFLOPS) в зависимости от числа параллельных процессов и объёма выборки.]]

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

1) [https://github.com/artpar/Hard-Clustering-implementation Последовательная реализация на С++ ]

2) [http://projects.jasmeet.me/2013/03/HardCMeans.html Последовательная реализация на MatLab ]

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

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

Обсуждение участника:Светлана Лукьяненко

2016-11-22T12:28:34Z

Coctic:

= Статья [[Участник:Светлана Лукьяненко/Строгий алгоритм С средних (Hard C-Means, HCM)]] =
* Не указан вклад каждого автора [[Участник:Coctic|Coctic]] ([[Обсуждение участника:Coctic|обсуждение]]) 10:57, 25 октября 2016 (MSK)
** Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 15:05, 31 октября 2016 (MSK)
* Значительная часть п. 1.2 совпадает с тем же пунктом из [[Участник:Каледа Александр/Строгий алгоритм С средних (Hard C-Means)]] [[Участник:Coctic|Coctic]] ([[Обсуждение участника:Coctic|обсуждение]]) 11:05, 25 октября 2016 (MSK)
** Замечание снимается [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 15:05, 31 октября 2016 (MSK)
* В списке литературы отсутствуют выходные данные публикаций, кроме названия и автора. По приведенным данным определить конкретную публикацию не представляется возможным. Стоит добавить ссылку на оригинальную публикацию с описанием алгоритма, упомянутую в начале п.1.1 [[Участник:Coctic|Coctic]] ([[Обсуждение участника:Coctic|обсуждение]]) 10:57, 25 октября 2016 (MSK)
** Не исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 15:05, 31 октября 2016 (MSK)
* Список литературы совпадает со списком из [[Участник:Каледа Александр/Строгий алгоритм С средних (Hard C-Means)]] [[Участник:Coctic|Coctic]] ([[Обсуждение участника:Coctic|обсуждение]]) 11:01, 25 октября 2016 (MSK)
** Замечание снимается [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 15:05, 31 октября 2016 (MSK)
----------------------
* Комментарий от [[Участник:Юрий Комаров|Комарова Юрия]]: Сравните, пожалуйста, нашу историю работы над статьёй с историей работы над статьёй наших коллег: Каледы и его товарища. Сделав это, Вы обнаружите, что мы начали работать сразу же после выдачи задания, практически одними из первых и гораздо раньше указанных ребят, и неоднократно правили каждый из пунктов, доводя их до лучшей кондиции. За то, что пункт 1.2, как, впрочем, и другие пункты, и список литературы были составлены нами лично в процессе длительной совместной работы со [[Участник:Светлана Лукьяненко|Светланой]], отвечаю головой. Надеюсь, вопрос о плагиате больше не возникнет. В такой ситуации исправлять что-то должны явно не мы. С уважением, Комаров Юрий.
** В мои задачи не входить обвинять кого-то в плагиате, проводить расследования, кто у кого списал, или выяснять, кто прав, а кто нет. Меня попросили проверить статью, обращая внимание на пересечения с другими на ту же тему. В двух статьях есть общая часть, это пошло в замечания к обеим статьям. Пересечение уйдет - замечание снимется. Кто исправит текст - мне все равно. Когда в статье появится метка, что ее можно снова проверять - я сравню тексты снова. Пока текст совпадает - замечание с моей стороны остается. Есть А.С. Антонов, если он сочтет, что это замечание можно проигнорировать (в одной статье или в обеих) - он продвинет статью дальше. [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 18:31, 28 октября 2016 (MSK)
** Если говорить о, скажем мягко, некорректном заимствовании, то ваш п 1.2 есть воспроизведение фрагмента из работы Нейского с небольшими добавлениями. У вас имеется разрешение автора на такое воспроизведение? Так что не стоит так сразу головой-то... [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 18:31, 28 октября 2016 (MSK)
** В общем, не стоит отвечать в таком тоне. Я могу понять возмущение, но писать надо корректнее. [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 18:31, 28 октября 2016 (MSK)
* Вклад авторов указан, в источниках приведены ссылки. Исправлять часть статьи, которую у нас украли наши коллеги (дата создания их страницы 15 октября), должны не мы, а указанные личности. К сожалению, заставить их это сделать мы не можем, полагаю, регулирование этого вопроса нам разумнее доверить проверяющим.

-----
* В списке литературы отсутствуют выходные данные публикаций, кроме названия и автора. По приведенным данным определить конкретную публикацию не представляется возможным. Стоит добавить ссылку на оригинальную публикацию с описанием алгоритма, упомянутую в начале п.1.1 [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 15:05, 31 октября 2016 (MSK)
** Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 11:06, 3 ноября 2016 (MSK)

----
* п. 2.4. Не приведена ссылка на текст анализируемой программы. [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 10:38, 17 ноября 2016 (MSK)
** Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 15:28, 22 ноября 2016 (MSK)
* Необходимо указать характеристики программно-аппаратной платформы (какой компилятор, с какими опциями использовался, какие версии библиотек, на каких узлах проводился запуск и т.д.) [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 15:28, 22 ноября 2016 (MSK)
* В подписи к рис. 3 указано, что это ''График производительности ... от числа параллельных процессов'', а подписи к оси указано, что по ней отложено число процессоров (Processors). Какой вариант правильный? [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 15:28, 22 ноября 2016 (MSK)

Участник:Gkhazeeva/Нечеткий алгоритм C средних

2016-11-22T12:24:48Z

Coctic:

{{Assignment|{{REVISIONUSER}}}}

{{algorithm
| name = Нечеткий алгоритм C средних
| serial_complexity = <math>O(Mdc^2i)</math>, <math>i</math> - количество итераций
| input_data = <math>M*d</math>, [количество наблюдений * размерность]
| output_data = <math>M*c</math>, [количество наблюдений * количество кластеров]
| pf_height = <math>2i</math>
| pf_width = <math>n</math>
}}

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

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

== Общее описание алгоритма ==
Кластеризация - это объединение объектов в группы (кластеры) на основе схожести признаков для объектов одной группы и отличий между группами. Нечеткий алгоритм C Средних (Fuzzy C-means, FCM) - алгоритм кластеризации, позволяющий объектам принадлежать с различной степенью нескольким кластерам одновременно. Впервые алгоритм был предложен J.C. Dunn в 1973 <ref>[http://www.tandfonline.com/doi/abs/10.1080/01969727308546046 | J. C. Dunn. A Fuzzy Relative of the ISODATA Process and Its Use in Detecting Compact Well-Separated Clusters. Journal of Cybernetics, volume 3,1973 - Issue 3, pp 32-57]</ref>. Нечеткое разбиение позволяет просто решить проблему объектов, расположенных на границе двух кластеров - им назначают степени принадлежностей равные 0.5.

Входные данные алгоритма: набор векторов, которые следует кластеризовать.

Параметры алгоритма: <math>c</math> - количество кластеров; <math>m</math> - экспоненциальный вес; <math>\varepsilon</math> - параметр останова алгоритма.

Выходные данные: матрица вероятностей принадлежности векторов кластерам.

Краткое описание алгоритма:

* Задать параметры алгоритма.

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

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

== Математическое описание алгоритма <ref>[http://it-claim.ru/Persons/Neyskiy/Article2_Neiskiy.pdf | Нейский И.М. Классификация и сравнение методов кластеризации.// Интеллектуальные технологии и системы. Сборник учебно-методических работ и статей аспирантов и студентов. – М.: НОК «CLAIM», 2006. – Выпуск 8. – С. 130-142.]</ref> ==

Пусть <math> W = w_{ij} \in[0,1],\; i = 1, ..., M, \; j = 1, ..., c</math> - матрица разбиения, где <math>w_{i,j}</math> - степень принадлежности объекта <math>i</math> к кластеру <math>j</math>; <math>c</math> - количество кластеров, <math>M</math> - количество векторов.

При этом элементы матрицы должны удовлетворять условиям:

* <math>\sum_{j = 1}^c w_{ij} = 1, i = 1, ..., M</math>                <math>(1)</math>
* <math>0 < \sum_{i = 1}^M w_{ij} < M, j = 1, ..., c</math>       <math>(2)</math>

Тогда алгоритм принимает следующий вид:

1) Задаем параметры алгоритма: <math>c</math> - количество кластеров; <math>m >= 1</math> - экспоненциальный вес, определяющий нечеткость кластеров; <math>\varepsilon > 0</math> - параметр останова алгоритма.

2) Генерируем случайным образом матрицу нечеткого разбиения с учетом условий <math>(1)</math> и <math>(2)</math>

3) Рассчитываем центроиды (центры кластеров): <math>V_j = {{\sum_{i=1}^M w_{ij}^m * X_i} \over {\sum_{i=1}^M w_{ij}^m}}, j = 1, ..., c</math>

4) Рассчитываем расстояния между объектами <math>X</math> и центроидами:

<math>D_{ij} = {||X_i - V_j||}, i = 1,...,M; j = 1,...,c </math>

5) Пересчет элементов матрицы разбиения:

при <math>D_{ij} >0</math> : <math>w_{ij} = {{1}\over {{ (\sum_{k=1}^c {{D_{ij}}\over{D_{ik}}} ) }^{2/(m-1)}}}, j = 1,...,c</math>

при <math>D_{ij} =0</math> : <math>w_{ij} = \delta_{ij}, j = 1,...,c</math>, где <math>\delta_{ij}</math> - символ Кронекера

6) Если <math>|| F - F^{*} || < \varepsilon </math>, где <math>F^{*}</math> - матрица нечеткого разбиения предыдущей итерации, то идем далее, иначе возвращаемся на пункт 3.

7) Конец.

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

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

* Поиск <math>V_j</math> - расчет центроидов (пункт 3 алгоритма)
* Нахождение <math>D_{ij}</math> - расстояний между объектами (пункт 4 алгоритма)
* Пересчет <math>w_{ij}</math> - элементов матрицы разбиения (пункт 5 алгоритма)

== Макроструктура алгоритма ==
Основные шаги при реализации алгоритма
* Генерация случайной матрицы размера <math>M</math> на где <math>c</math>, проверка условий
* Расчет центроидов – по сути, скалярное произведение с нормировкой
* Расчет расстояний – в общепринятом случае является скалярным произведением
* Пересчет матрицы – по сути, скалярное произведение
* Проверка условий останова – вычисление нормы

== Схема реализации последовательного алгоритма ==
float ** FuzzyCMeans (float** X, c, m, eps){
n = X.size();
r = X[0].size();
centers = generateZeroFill(c, r)
Wprev = genetateRandFill(n, c);
W = Wprev;
while (true){
// обновляем центры кластеров
for (int i=0; i<c; i++){
float * num = new float []();
float den = 0;
for (int j=0; j<n; j++){
num += pow(W[j][i], m) * X[j];
den+=pow(W[j][i], m);
}
centers[i] = num / den;
}
//обновляем вероятности W и считаем расстояние между матрицами W и Wprev
float max_diff = 0;
for (int i=0; i<n; i++)
for (int j=0; j<c; j++){
total = 0;
for (int m=0; m<с; m++)
total += pow(distance(X[i], centers[j]) / distance(X[i], centers[m]), 2/(m-1));
W[i][j] = 1/total;
max_diff = max(abs(Wprev[i][j]-W[i][j]), max_diff);
Wprev[i][j] = W[i][j];
}
if (max_diff < eps):
break;
}
return W;
}

== Последовательная сложность алгоритма ==
Последовательная сложность алгоритма состоит из сложности каждой итерации умноженной на их количество. Так как число итераций заранее неизвестно и зависит от входных параметров, рассмотрим сложность на каждой итерации. Наибольшую сложность представляет собой пересчет матрицы, сложность которого <math>O(c^2 nd)</math> (по сравнению со сложностью <math>O(cnd)</math> расчета расстояний, вычисления центроидов и проверки условия останова). Итого общая сложность алгоритма <math>O(c^2 ndi)</math>

== Информационный граф ==
Информационный граф представлен на рисунке ниже.

'''Первый ярус''' состоит из <math>M</math> параллельных операций 1, 2, совершаемых в цикле <math>c</math> раз для каждого кластера.

'''Операция 1''': <math>w_{ij}^m</math>, где <math>j</math> - номер итерации в цикле, <math>i</math> - номер параллельной ветви.

'''Операция 2''': <math>w_{ij}^m*X_i</math>

Здесь <math>j</math> - номер итерации в цикле, <math>i</math> - номер параллельной ветви.

На выходе из каждой ветки получаем вектор размера <math>1</math> x <math>c</math> и матрицу размера <math>d</math> x <math>c</math>.
Далее совершаем поэлементное сложение векторов и матриц соответственно, а затем делим каждый столбец в матрице на соответствующий элемент в векторе.

'''Второй ярус''' состоит их <math>M</math> параллельных операций 3, 4, 5 также совершаемых в цикле <math>c</math> раз.

'''Операция 3''': обновление значения <math>w_{ij}</math> по указанной в разделе 1.2 в пункте 5 формуле.

'''Операция 4''': <math>maximum = max(|w_{ij} - w_{ij}^{prev}|, maximum)</math>.

'''Операция 5''': <math>w_{ij}^{prev} = w_{ij}</math>.

Здесь <math>j</math> - номер итерации в цикле, <math>i</math> - номер параллельной ветви.

На выходе из каждой ветки получаем число <math>maximum</math>. Далее находим максимальное значение из полученных величин для каждой ветки. Затем проверяем условие останова алгоритма.

[[File:Scheme3.JPG]]

== Ресурс параллелизма алгоритма ==
Параллельная сложность алгоритма: <math>M*c^2*i</math>. Такая сложность получается за счет распараллеливания на каждом ярусе <math>M</math> операций. Иерархическая структура параллелизма подробно описана в [[#Информационный граф|п.1.7]].

В алгоритме не возникает скошенного параллелизма.

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

* Входные данные алгоритма: набор векторов <math>x_i</math> размерности <math>d</math>, где <math>i = 1,...,M</math>; <math>M</math> - количество векторов.
* Объем входных данных: <math>M*d</math> , [количество наблюдений * размерность].
* Выходные данные алгоритма: матрица вероятностей принадлежности векторов кластерам <math>M</math> на <math>c</math>.
* Объем выходных данных: <math>M*c</math> , [количество наблюдений * количество кластеров].

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

* Соотношение последовательной и параллельной формы алгоритма: <math>M</math>
* Вычислительная мощность: <math>{dc^2i} \over {c+d}</math>.
* Устойчивость: алгоритм не является устойчивым, поэтому существует много исследований о том, как первоначально выбрать параметры кластеризации.
* Сбалансированность: в данном алгоритме операция умножения доминирует над операцией сложения. Операции между параллельными ветвями сбалансированны.
* Детерминированность: алгоритм не является детерминированным, так как матрица нечеткого разбиение генерируется произвольно.
* Степень исхода вершины информационного графа ( для одной интерации): 2 (3 - с учетом, если выходные данные пошли на следующую итерацию).

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

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

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

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

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

Проведём исследование масштабируемости параллельной реализации нечеткого алгоритма С-средних.
Исследование проводилось на суперкомпьютере "Ломоносов"<ref name="Lom">Воеводин Вл., Жуматий С., Соболев С., Антонов А., Брызгалов П., Никитенко Д., Стефанов К., Воеводин Вад. Практика суперкомпьютера «Ломоносов» // Открытые системы, 2012, N 7, С. 36-39.</ref> [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета].
Была исследована собственная параллельная реализация алгоритма, написанная на языке C++ с использованием стандарта MPI. Сборка программы производилась при помощи компилятора компании Intel версии 13.1.0 с использованием библиотеки intelMPI версии 4.1.0 . Расчеты проводились в разделе test на узлах со следующими характеристиками: количество GPU - 0, количество ядер - 8 ядер архитектуры x86, количество памяти - 12 Гб.

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

* число процессоров [1 : 128];
* размер матрицы [10000 : 80000].

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

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

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

[[file: FuzzyCMeansPerformance.png |thumb|center|700px|Рисунок 1. Параллельная реализация нечеткого алгоритма С-средних. Изменение производительности в зависимости от числа процессоров и размера матрицы.]]
[[file: FuzzyCMeansEfficiency2.png|thumb|center|700px|Рисунок 2. Параллельная реализация нечеткого алгоритма С-средних. Изменение эффективности реализации в зависимости от числа процессоров и размера матрицы.]]

Построим оценки масштабируемости выбранной реализации нечеткого алгоритма С-средних:
* По числу процессов: 0.007. При увеличении числа процессов эффективность на рассмотренной области изменений параметров запуска увеличивается.
* По размеру задачи: -0.0016. При увеличении размера задачи эффективность уменьшается.
* По двум направлениям: 0,000077. При рассмотрении увеличения как вычислительной сложности, так и числа процессов на всей рассмотренной области значений эффективность увеличивается, однако скорость увеличения эффективности небольшая.

Была использована следующая реализация алгоритма.

#include <mpi.h>
#include <stdio.h>
#include <iostream>
#include <stdlib.h>
#include <math.h>
#include <string.h>
#include <time.h>
using namespace std;
double **x; //input matrix of size (n x x_dim)
int n;
int x_dim;
double **centroids; //cluster centroids matrix of size (n_cluster x x_dim)
int n_cluster; // number of clusters
double **w; //probability matrix of size (n x n_cluster)
double **dist; //distances matrix of size (n x n_cluster)
double eps; //max error
double m; //parameter of algo
int max_iter; // max num of iterations
double **num;
double *den;
double *allden;
double *err;
double *total_err;
int rank, size;
double ** generateZerosMatrix(int r, int c){
double ** arr = new double* [r];
for (int i = 0; i < r; ++i){
arr[i] = new double[c]();
}
return arr;
}
int generate_data()
{
//generate matrix
x = generateZerosMatrix(n, x_dim);
centroids = generateZerosMatrix(n_cluster, x_dim);
w = generateZerosMatrix(n, n_cluster);
dist = generateZerosMatrix(n, n_cluster);
num = generateZerosMatrix(n_cluster, x_dim);
//generate vectors
den = new double [n_cluster]();
allden = new double [n_cluster]();
//for stopping algorithm
err = new double;
total_err = new double;
srand(time(0));
//initialize w randomly with restrictions
for (int i = 0; i < n; ++i){
double sum = 0;
for (int j = 0; j < n_cluster; ++j){
w[i][j] = rand();
sum += w[i][j];
}
for (int j = 0; j < n_cluster; ++j){
w[i][j] /= sum;
}
}
//initialize x randomly
for (int i = 0; i < n; ++i)
for (int j = 0; j < x_dim; ++j)
x[i][j] = rand();
return 0;
}
double make_iteration() {
// calculate centroids centers
for (int i = rank; i < n; i+=size)
for (int j = 0; j < n_cluster; ++j){
double mu = pow(w[i][j], m);
den[j] += mu;
for (int k = 0; k < x_dim; ++k)
num[j][k] = mu * x[i][k];
}
MPI_Allreduce(den, allden, n_cluster, MPI_DOUBLE, MPI_SUM, MPI_COMM_WORLD);
for (int j=0; j < n_cluster; ++j)
MPI_Allreduce(num[j], centroids[j], x_dim, MPI_DOUBLE, MPI_SUM, MPI_COMM_WORLD);
for (int i = 0; i < n_cluster; ++i)
for (int j = 0; j < x_dim; ++j)
centroids[i][j] /= allden[i];
// calculate distances and probabilities, check stop conditions
double err = 0.0;
for (int i = rank; i < n; i+=size)
for (int j = 0; j < n_cluster; ++j){
for (int k = 0; k < x_dim; ++k)
dist[i][j] += (x[i][k] - centroids[j][k]) * (x[i][k] - centroids[j][k]);
double w_prev = w[i][j];
for (int k = 0; k < n_cluster; ++k)
w[i][j] += dist[i][j] / dist[i][k];
w[i][j] = 1.0 / pow(w[i][j], 1.0 / (m - 1));
err = fmax(err, abs(w_prev - w[i][j]));
}
return err;
}
int FCM(){
*total_err = eps+1;
int cur_iter = 0;
while (cur_iter < max_iter && *total_err > eps){
*err = make_iteration();
MPI_Allreduce(err, total_err, 1, MPI_DOUBLE, MPI_MAX, MPI_COMM_WORLD);
cur_iter++;
}
return cur_iter;
}
void clearMatrix(double ** matr, int r, int c){
for (int i = 0; i < r; ++i){
delete [] matr[i];
}
delete [] matr;
}
int memory_free(){
clearMatrix(x, n, x_dim);
clearMatrix(centroids, n_cluster, x_dim);
clearMatrix(w, n_cluster, n);
clearMatrix(num, n_cluster, x_dim);
clearMatrix(dist, n, n_cluster);
delete [] den;
delete [] allden;
delete err;
delete total_err;
return 0;
}
int main(int argc, char **argv){
MPI_Init(&argc, &argv);
MPI_Comm_size(MPI_COMM_WORLD, &size);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
int n_repeat = strtol(argv[1], NULL, 10);
int nx_min = strtol(argv[2], NULL, 10);
int nx_max = strtol(argv[3], NULL, 10);
int step = strtol(argv[4], NULL, 10);
x_dim = strtol(argv[5], NULL, 10);
m = strtod(argv[6], NULL);
n_cluster = strtol(argv[7], NULL, 10);
max_iter = strtol(argv[8], NULL, 10);
eps = strtod(argv[9], NULL);
//for all input matrix sizes
for (n = nx_min; n <= nx_max; n += step){
double start, finish, time_elapsed_iter=0;
int total_iterations = 0;
//repeat for getting mean value
for (int i = 0; i < n_repeat; ++i) {
generate_data();
MPI_Barrier(MPI_COMM_WORLD);
start = MPI_Wtime();
total_iterations += FCM();
finish = MPI_Wtime();
memory_free();
time_elapsed_iter += (finish-start);
}
time_elapsed_iter /= total_iterations;
if (rank == 0) {
cout << n << " " << size << " " << time_elapsed_iter << endl;
}
}
MPI_Finalize();
}

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

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

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

* Реализация алгоритма на POSTGRESQL: http://num-meth.srcc.msu.ru/zhurnal/tom_2012/pdf/v13r207.pdf
* Библиотека для MATLAB: http://www.mathworks.com/help/fuzzy/fcm.html (распространяется на коммерческой основе)

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

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

2016-11-22T12:24:30Z

Coctic:

= Статья [[Участник:Gkhazeeva/Нечеткий алгоритм C средних]] =
* Не указан вклад каждого автора [[Участник:Coctic|Coctic]] ([[Обсуждение участника:Coctic|обсуждение]]) 12:54, 25 октября 2016 (MSK)
** Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 10:55, 1 ноября 2016 (MSK)
* п. 1.2 номера формул следует выравнивать по правому краю, а не прилеплять вплотную к формуле [[Участник:Coctic|Coctic]] ([[Обсуждение участника:Coctic|обсуждение]]) 12:54, 25 октября 2016 (MSK)
** Условно исправлено. Форматирование сделано негодными средствами, но неясно, установлены ли средства (https://en.wikipedia.org/wiki/Help:Displaying_a_formula#Equation_numbering), чтобы сделать правильно [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 10:55, 1 ноября 2016 (MSK)
*** Пробовал сделать указанными Вами средствами - на этом ресурсе указанные Вами шаблоны не заработали [[Участник:Yushin|Павел Юшин]]
* п. 1.3 состоит из одного предложения и не дает достаточно информации [[Участник:Coctic|Coctic]] ([[Обсуждение участника:Coctic|обсуждение]]) 12:54, 25 октября 2016 (MSK)
** Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 10:55, 1 ноября 2016 (MSK)
* п. 1.7 приведенный рисунок не является информационным графом: не все дуги ориентированы, имеются циклы [[Участник:Coctic|Coctic]] ([[Обсуждение участника:Coctic|обсуждение]]) 12:54, 25 октября 2016 (MSK)
** Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 10:55, 1 ноября 2016 (MSK)
* п. 1.9 не приведено оценки объема входных и выходных данных [[Участник:Coctic|Coctic]] ([[Обсуждение участника:Coctic|обсуждение]]) 12:54, 25 октября 2016 (MSK)
** Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 10:55, 1 ноября 2016 (MSK)
* в разделе 2 отсутствуют необходимые пункты, п. 2.2 должен быть 2.7 [[Участник:Coctic|Coctic]] ([[Обсуждение участника:Coctic|обсуждение]]) 12:54, 25 октября 2016 (MSK)
** Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 10:55, 1 ноября 2016 (MSK)
* В списке литературы 1 ссылка - скопированный шаблон без реальной ссылки, 2 ссылка - просто URL без выходных данных источника [[Участник:Coctic|Coctic]] ([[Обсуждение участника:Coctic|обсуждение]]) 12:54, 25 октября 2016 (MSK)
** Исправлено частично. Ссылка 2 по-прежнему не имеет достаточных выходных данных [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 10:55, 1 ноября 2016 (MSK)
*** На сайте, где студентам выдавалось задание ( http://parallel.ru/ss16 ), данный материал предоставлялся в списке источников (номер [8]) в таком же виде, как он указан в данной статье [[Участник:Yushin|Павел Юшин]]
**** Не вижу никакого противоречия с тем, что я написал в замечании [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 10:47, 7 ноября 2016 (MSK)
**** Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 16:34, 13 ноября 2016 (MSK)

----
* п. 2.4. Приведен график зависимости эффективности от параметров задачи. Не указано, о какой конкретно эффективности идет речь. [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 10:29, 17 ноября 2016 (MSK)
** Была ссылка в справочный раздел с описанием эффективности
** Подпись под рисункам должна быть самодостаточна, без необходимости разбираться, куда была ссылка и какую ссылку искать. То же касается текста: он должен быть понятен без необходимости ходить по ссылкам, ссылки - средство предоставить дополнительную информацию, для уточнения деталей. [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 16:31, 18 ноября 2016 (MSK)
** Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 10:24, 21 ноября 2016 (MSK)
* Необходимо указать характеристики программно-аппаратной платформы (какой компилятор, с какими опциями использовался, какие версии библиотек, на каких узлах проводился запуск и т.д.) [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 10:24, 21 ноября 2016 (MSK)
** Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 15:24, 22 ноября 2016 (MSK)

Участник:Gkhazeeva/Нечеткий алгоритм C средних

2016-11-21T07:24:40Z

Coctic:

{{algorithm
| name = Нечеткий алгоритм C средних
| serial_complexity = <math>O(Mdc^2i)</math>, <math>i</math> - количество итераций
| input_data = <math>M*d</math>, [количество наблюдений * размерность]
| output_data = <math>M*c</math>, [количество наблюдений * количество кластеров]
| pf_height = <math>2i</math>
| pf_width = <math>n</math>
}}

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

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

== Общее описание алгоритма ==
Кластеризация - это объединение объектов в группы (кластеры) на основе схожести признаков для объектов одной группы и отличий между группами. Нечеткий алгоритм C Средних (Fuzzy C-means, FCM) - алгоритм кластеризации, позволяющий объектам принадлежать с различной степенью нескольким кластерам одновременно. Впервые алгоритм был предложен J.C. Dunn в 1973 <ref>[http://www.tandfonline.com/doi/abs/10.1080/01969727308546046 | J. C. Dunn. A Fuzzy Relative of the ISODATA Process and Its Use in Detecting Compact Well-Separated Clusters. Journal of Cybernetics, volume 3,1973 - Issue 3, pp 32-57]</ref>. Нечеткое разбиение позволяет просто решить проблему объектов, расположенных на границе двух кластеров - им назначают степени принадлежностей равные 0.5.

Входные данные алгоритма: набор векторов, которые следует кластеризовать.

Параметры алгоритма: <math>c</math> - количество кластеров; <math>m</math> - экспоненциальный вес; <math>\varepsilon</math> - параметр останова алгоритма.

Выходные данные: матрица вероятностей принадлежности векторов кластерам.

Краткое описание алгоритма:

* Задать параметры алгоритма.

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

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

== Математическое описание алгоритма <ref>[http://it-claim.ru/Persons/Neyskiy/Article2_Neiskiy.pdf | Нейский И.М. Классификация и сравнение методов кластеризации.// Интеллектуальные технологии и системы. Сборник учебно-методических работ и статей аспирантов и студентов. – М.: НОК «CLAIM», 2006. – Выпуск 8. – С. 130-142.]</ref> ==

Пусть <math> W = w_{ij} \in[0,1],\; i = 1, ..., M, \; j = 1, ..., c</math> - матрица разбиения, где <math>w_{i,j}</math> - степень принадлежности объекта <math>i</math> к кластеру <math>j</math>; <math>c</math> - количество кластеров, <math>M</math> - количество векторов.

При этом элементы матрицы должны удовлетворять условиям:

* <math>\sum_{j = 1}^c w_{ij} = 1, i = 1, ..., M</math>                <math>(1)</math>
* <math>0 < \sum_{i = 1}^M w_{ij} < M, j = 1, ..., c</math>       <math>(2)</math>

Тогда алгоритм принимает следующий вид:

1) Задаем параметры алгоритма: <math>c</math> - количество кластеров; <math>m >= 1</math> - экспоненциальный вес, определяющий нечеткость кластеров; <math>\varepsilon > 0</math> - параметр останова алгоритма.

2) Генерируем случайным образом матрицу нечеткого разбиения с учетом условий <math>(1)</math> и <math>(2)</math>

3) Рассчитываем центроиды (центры кластеров): <math>V_j = {{\sum_{i=1}^M w_{ij}^m * X_i} \over {\sum_{i=1}^M w_{ij}^m}}, j = 1, ..., c</math>

4) Рассчитываем расстояния между объектами <math>X</math> и центроидами:

<math>D_{ij} = {||X_i - V_j||}, i = 1,...,M; j = 1,...,c </math>

5) Пересчет элементов матрицы разбиения:

при <math>D_{ij} >0</math> : <math>w_{ij} = {{1}\over {{ (\sum_{k=1}^c {{D_{ij}}\over{D_{ik}}} ) }^{2/(m-1)}}}, j = 1,...,c</math>

при <math>D_{ij} =0</math> : <math>w_{ij} = \delta_{ij}, j = 1,...,c</math>, где <math>\delta_{ij}</math> - символ Кронекера

6) Если <math>|| F - F^{*} || < \varepsilon </math>, где <math>F^{*}</math> - матрица нечеткого разбиения предыдущей итерации, то идем далее, иначе возвращаемся на пункт 3.

7) Конец.

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

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

* Поиск <math>V_j</math> - расчет центроидов (пункт 3 алгоритма)
* Нахождение <math>D_{ij}</math> - расстояний между объектами (пункт 4 алгоритма)
* Пересчет <math>w_{ij}</math> - элементов матрицы разбиения (пункт 5 алгоритма)

== Макроструктура алгоритма ==
Основные шаги при реализации алгоритма
* Генерация случайной матрицы размера <math>M</math> на где <math>c</math>, проверка условий
* Расчет центроидов – по сути, скалярное произведение с нормировкой
* Расчет расстояний – в общепринятом случае является скалярным произведением
* Пересчет матрицы – по сути, скалярное произведение
* Проверка условий останова – вычисление нормы

== Схема реализации последовательного алгоритма ==
float ** FuzzyCMeans (float** X, c, m, eps){
n = X.size();
r = X[0].size();
centers = generateZeroFill(c, r)
Wprev = genetateRandFill(n, c);
W = Wprev;
while (true){
// обновляем центры кластеров
for (int i=0; i<c; i++){
float * num = new float []();
float den = 0;
for (int j=0; j<n; j++){
num += pow(W[j][i], m) * X[j];
den+=pow(W[j][i], m);
}
centers[i] = num / den;
}
//обновляем вероятности W и считаем расстояние между матрицами W и Wprev
float max_diff = 0;
for (int i=0; i<n; i++)
for (int j=0; j<c; j++){
total = 0;
for (int m=0; m<с; m++)
total += pow(distance(X[i], centers[j]) / distance(X[i], centers[m]), 2/(m-1));
W[i][j] = 1/total;
max_diff = max(abs(Wprev[i][j]-W[i][j]), max_diff);
Wprev[i][j] = W[i][j];
}
if (max_diff < eps):
break;
}
return W;
}

== Последовательная сложность алгоритма ==
Последовательная сложность алгоритма состоит из сложности каждой итерации умноженной на их количество. Так как число итераций заранее неизвестно и зависит от входных параметров, рассмотрим сложность на каждой итерации. Наибольшую сложность представляет собой пересчет матрицы, сложность которого <math>O(c^2 nd)</math> (по сравнению со сложностью <math>O(cnd)</math> расчета расстояний, вычисления центроидов и проверки условия останова). Итого общая сложность алгоритма <math>O(c^2 ndi)</math>

== Информационный граф ==
Информационный граф представлен на рисунке ниже.

'''Первый ярус''' состоит из <math>M</math> параллельных операций 1, 2, совершаемых в цикле <math>c</math> раз для каждого кластера.

'''Операция 1''': <math>w_{ij}^m</math>, где <math>j</math> - номер итерации в цикле, <math>i</math> - номер параллельной ветви.

'''Операция 2''': <math>w_{ij}^m*X_i</math>

Здесь <math>j</math> - номер итерации в цикле, <math>i</math> - номер параллельной ветви.

На выходе из каждой ветки получаем вектор размера <math>1</math> x <math>c</math> и матрицу размера <math>d</math> x <math>c</math>.
Далее совершаем поэлементное сложение векторов и матриц соответственно, а затем делим каждый столбец в матрице на соответствующий элемент в векторе.

'''Второй ярус''' состоит их <math>M</math> параллельных операций 3, 4, 5 также совершаемых в цикле <math>c</math> раз.

'''Операция 3''': обновление значения <math>w_{ij}</math> по указанной в разделе 1.2 в пункте 5 формуле.

'''Операция 4''': <math>maximum = max(|w_{ij} - w_{ij}^{prev}|, maximum)</math>.

'''Операция 5''': <math>w_{ij}^{prev} = w_{ij}</math>.

Здесь <math>j</math> - номер итерации в цикле, <math>i</math> - номер параллельной ветви.

На выходе из каждой ветки получаем число <math>maximum</math>. Далее находим максимальное значение из полученных величин для каждой ветки. Затем проверяем условие останова алгоритма.

[[File:Scheme3.JPG]]

== Ресурс параллелизма алгоритма ==
Параллельная сложность алгоритма: <math>M*c^2*i</math>. Такая сложность получается за счет распараллеливания на каждом ярусе <math>M</math> операций. Иерархическая структура параллелизма подробно описана в [[#Информационный граф|п.1.7]].

В алгоритме не возникает скошенного параллелизма.

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

* Входные данные алгоритма: набор векторов <math>x_i</math> размерности <math>d</math>, где <math>i = 1,...,M</math>; <math>M</math> - количество векторов.
* Объем входных данных: <math>M*d</math> , [количество наблюдений * размерность].
* Выходные данные алгоритма: матрица вероятностей принадлежности векторов кластерам <math>M</math> на <math>c</math>.
* Объем выходных данных: <math>M*c</math> , [количество наблюдений * количество кластеров].

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

* Соотношение последовательной и параллельной формы алгоритма: <math>M</math>
* Вычислительная мощность: <math>{dc^2i} \over {c+d}</math>.
* Устойчивость: алгоритм не является устойчивым, поэтому существует много исследований о том, как первоначально выбрать параметры кластеризации.
* Сбалансированность: в данном алгоритме операция умножения доминирует над операцией сложения. Операции между параллельными ветвями сбалансированны.
* Детерминированность: алгоритм не является детерминированным, так как матрица нечеткого разбиение генерируется произвольно.
* Степень исхода вершины информационного графа ( для одной интерации): 2 (3 - с учетом, если выходные данные пошли на следующую итерацию).

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

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

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

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

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

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

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

* число процессоров [1 : 128];
* размер матрицы [10000 : 80000].

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

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

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

[[file: FuzzyCMeansPerformance.png |thumb|center|700px|Рисунок 1. Параллельная реализация нечеткого алгоритма С-средних. Изменение производительности в зависимости от числа процессоров и размера матрицы.]]
[[file: FuzzyCMeansEfficiency2.png|thumb|center|700px|Рисунок 2. Параллельная реализация нечеткого алгоритма С-средних. Изменение эффективности реализации в зависимости от числа процессоров и размера матрицы.]]

Построим оценки масштабируемости выбранной реализации нечеткого алгоритма С-средних:
* По числу процессов: 0.007. При увеличении числа процессов эффективность на рассмотренной области изменений параметров запуска увеличивается.
* По размеру задачи: -0.0016. При увеличении размера задачи эффективность уменьшается.
* По двум направлениям: 0,000077. При рассмотрении увеличения как вычислительной сложности, так и числа процессов на всей рассмотренной области значений эффективность увеличивается, однако скорость увеличения эффективности небольшая.

Была использована следующая реализация алгоритма.

#include <mpi.h>
#include <stdio.h>
#include <iostream>
#include <stdlib.h>
#include <math.h>
#include <string.h>
#include <time.h>
using namespace std;
double **x; //input matrix of size (n x x_dim)
int n;
int x_dim;
double **centroids; //cluster centroids matrix of size (n_cluster x x_dim)
int n_cluster; // number of clusters
double **w; //probability matrix of size (n x n_cluster)
double **dist; //distances matrix of size (n x n_cluster)
double eps; //max error
double m; //parameter of algo
int max_iter; // max num of iterations
double **num;
double *den;
double *allden;
double *err;
double *total_err;
int rank, size;
double ** generateZerosMatrix(int r, int c){
double ** arr = new double* [r];
for (int i = 0; i < r; ++i){
arr[i] = new double[c]();
}
return arr;
}
int generate_data()
{
//generate matrix
x = generateZerosMatrix(n, x_dim);
centroids = generateZerosMatrix(n_cluster, x_dim);
w = generateZerosMatrix(n, n_cluster);
dist = generateZerosMatrix(n, n_cluster);
num = generateZerosMatrix(n_cluster, x_dim);
//generate vectors
den = new double [n_cluster]();
allden = new double [n_cluster]();
//for stopping algorithm
err = new double;
total_err = new double;
srand(time(0));
//initialize w randomly with restrictions
for (int i = 0; i < n; ++i){
double sum = 0;
for (int j = 0; j < n_cluster; ++j){
w[i][j] = rand();
sum += w[i][j];
}
for (int j = 0; j < n_cluster; ++j){
w[i][j] /= sum;
}
}
//initialize x randomly
for (int i = 0; i < n; ++i)
for (int j = 0; j < x_dim; ++j)
x[i][j] = rand();
return 0;
}
double make_iteration() {
// calculate centroids centers
for (int i = rank; i < n; i+=size)
for (int j = 0; j < n_cluster; ++j){
double mu = pow(w[i][j], m);
den[j] += mu;
for (int k = 0; k < x_dim; ++k)
num[j][k] = mu * x[i][k];
}
MPI_Allreduce(den, allden, n_cluster, MPI_DOUBLE, MPI_SUM, MPI_COMM_WORLD);
for (int j=0; j < n_cluster; ++j)
MPI_Allreduce(num[j], centroids[j], x_dim, MPI_DOUBLE, MPI_SUM, MPI_COMM_WORLD);
for (int i = 0; i < n_cluster; ++i)
for (int j = 0; j < x_dim; ++j)
centroids[i][j] /= allden[i];
// calculate distances and probabilities, check stop conditions
double err = 0.0;
for (int i = rank; i < n; i+=size)
for (int j = 0; j < n_cluster; ++j){
for (int k = 0; k < x_dim; ++k)
dist[i][j] += (x[i][k] - centroids[j][k]) * (x[i][k] - centroids[j][k]);
double w_prev = w[i][j];
for (int k = 0; k < n_cluster; ++k)
w[i][j] += dist[i][j] / dist[i][k];
w[i][j] = 1.0 / pow(w[i][j], 1.0 / (m - 1));
err = fmax(err, abs(w_prev - w[i][j]));
}
return err;
}
int FCM(){
*total_err = eps+1;
int cur_iter = 0;
while (cur_iter < max_iter && *total_err > eps){
*err = make_iteration();
MPI_Allreduce(err, total_err, 1, MPI_DOUBLE, MPI_MAX, MPI_COMM_WORLD);
cur_iter++;
}
return cur_iter;
}
void clearMatrix(double ** matr, int r, int c){
for (int i = 0; i < r; ++i){
delete [] matr[i];
}
delete [] matr;
}
int memory_free(){
clearMatrix(x, n, x_dim);
clearMatrix(centroids, n_cluster, x_dim);
clearMatrix(w, n_cluster, n);
clearMatrix(num, n_cluster, x_dim);
clearMatrix(dist, n, n_cluster);
delete [] den;
delete [] allden;
delete err;
delete total_err;
return 0;
}
int main(int argc, char **argv){
MPI_Init(&argc, &argv);
MPI_Comm_size(MPI_COMM_WORLD, &size);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
int n_repeat = strtol(argv[1], NULL, 10);
int nx_min = strtol(argv[2], NULL, 10);
int nx_max = strtol(argv[3], NULL, 10);
int step = strtol(argv[4], NULL, 10);
x_dim = strtol(argv[5], NULL, 10);
m = strtod(argv[6], NULL);
n_cluster = strtol(argv[7], NULL, 10);
max_iter = strtol(argv[8], NULL, 10);
eps = strtod(argv[9], NULL);
//for all input matrix sizes
for (n = nx_min; n <= nx_max; n += step){
double start, finish, time_elapsed_iter=0;
int total_iterations = 0;
//repeat for getting mean value
for (int i = 0; i < n_repeat; ++i) {
generate_data();
MPI_Barrier(MPI_COMM_WORLD);
start = MPI_Wtime();
total_iterations += FCM();
finish = MPI_Wtime();
memory_free();
time_elapsed_iter += (finish-start);
}
time_elapsed_iter /= total_iterations;
if (rank == 0) {
cout << n << " " << size << " " << time_elapsed_iter << endl;
}
}
MPI_Finalize();
}

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

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

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

* Реализация алгоритма на POSTGRESQL: http://num-meth.srcc.msu.ru/zhurnal/tom_2012/pdf/v13r207.pdf
* Библиотека для MATLAB: http://www.mathworks.com/help/fuzzy/fcm.html (распространяется на коммерческой основе)

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

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

2016-11-21T07:24:29Z

Coctic:

Участник:Nikmedoed/Нечеткий алгоритм С-средних (Fuzzy C-means)

2016-11-21T07:21:35Z

Coctic:

{{Assignment|{{REVISIONUSER}}}}
{{algorithm
| name = Нечеткий алгоритм С-средних (Fuzzy C-means)
| serial_complexity = <math>O(c^2 MI + cMnI), (I</math> - число итераций, <math>c</math> - количество кластеров, <math>M</math> - число точек, <math>n</math> - размерность точек (свойств на объект)<math>)</math>
| input_data = <math>Mn</math>
| output_data = <math>cM</math>
| pf_height = <math> O(c^2 I + cnI)</math>
| pf_width = <math>O( M )</math>
}}

Авторы: [[Участник:Nikmedoed|Н.А. Муромцев]] - перенос в вики, раздел 2, картинки, [[Участник:illusive_mike|М.С. Дворецкий]] - раздел 1

'''Нечеткий алгоритм С-средних''' (''Fuzzy C-means'') - позволяет получить нечёткую кластеризацию больших наборов числовых данных, что позволяет корректно определять объекты на границах кластеров. Однако, выполнение данного алгоритма требует серьёзных вычислительных ресурсов, а также изначального задания количества кластеров. Кроме того, может возникнуть неоднозначность с объектами, удалёнными от центров всех кластеров.

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

== Общее описание алгоритма ==
Алгоритм кластеризации Fuzzy C-Means (FCM) был предложен Дж. Данном в 1973 году <ref>Dunn, J.C.: A Fuzzy Relative of the ISODATA Process and Its Use in Detecting Compact Well-Separated Clusters. Journal of Cybernetics. 3 (1973): 32–57</ref> и доработан Дж. Бездеком в 1981 году <ref>Bezdek, J.C.: Pattern Recognition with Fuzzy Objective Function Algorithms. Plenum Press, New York (1981). ISBN 0-306-40671-3</ref>. В отличие от большинства существующих алгоритмов кластеризации, данный алгоритм является нечётким – каждый из объектов не входит однозначно в какой-либо кластер, а принадлежит всем кластерам с различными степенями принадлежности. Это даёт преимущества в качестве разбиения в случаях, когда кластеры находятся близко друг к другу, и большое число точек находится на их границах. Однако ценой такой нечёткости служат большие вычислительные затраты, чем у таких чётких алгоритмов, как [[Hard C-Means]] и [[K-Means]], при сохранении таких их недостатков, как априорное определение числа кластеров и отсутствие гарантии глобальной оптимальности результата.

== Математическое описание алгоритма ==
Исходные данные: массив объектов <math>{X_k}\in{\R^n}, k=\overline{1,M}</math>, число кластеров c, экспоненциальный вес <math>m\in{[1,\infty)}</math>, параметр останова <math>\varepsilon>0</math>.

Вычисляемые данные: матрица разбиения <math>F</math> размера <math>M\times c</math> (элементы <math>\mu_{ki}\in[0,1]</math>, <math>\sum^{c}_{i=1} {\mu_{ki}} = 1</math>), центры кластеров <math>V_i</math>, расстояния <math>D_{ki}</math> между объектами и центрами кластеров.

'''Формулы метода (вычисляются последовательно на каждой итерации):'''

1. Уточнение центров кластеров по степеням принадлежности
:<math>
\begin{align}
&V_i=\frac{\sum^{M}_{k=1} {\mu^m_{ki} * X_k}}{\sum^{M}_{k=1} {\mu^m_{ki}}},i=\overline{1,c}
\end{align}
</math>
2. Расчёт расстояний между новыми центрами кластеров и точками данных
:<math>
\begin{align}
&D_{ki}=\sqrt{{\lVert X_k - V_i \rVert}^2},k=\overline{1,M},i=\overline{1,c}
\end{align}
</math>
3. Пересчёт степеней принадлежности объектов кластерам
:<math>
\begin{align}
&\mu_{ki}=\frac{1}{{ \sum^{c}_{j=1} \left ( {\frac{D_{ki}}{D_{kj}}} \right ) }^{{2}/{m-1}}
},k=\overline{1,M},i=\overline{1,c}\\
\end{align}
</math>

На каждой итерации алгоритма происходит уточнение элементов матрицы <math>F</math>. Выходом алгоритма служит матрица <math>F</math>, к которой алгоритм сходится. Факт того, что алгоритм сошёлся, устанавливается проверкой вида <math>\max_{k = \overline{1,M},i = \overline{1,c}} {( \left | \mu_{ki} - \mu_{ki}^* \right |)} < \varepsilon</math> либо <math>\max_{i = \overline{1,c}} {( \left | V_i - V_i^* \right |)} < \varepsilon</math>, где <math>\mu_{ki}^* (V_i^*)</math> – значение <math>\mu_{ki}(V_i)</math>, вычисленное на предыдущей итерации.

== Вычислительное ядро алгоритма ==
Вычислительное ядро алгоритма Fuzzy C-Means составляют шаги вычисления центров кластеров, расстояний между ними и точками данных и в особенности пересчёта матрицы степеней принадлежности точек данных.

При реальном вычислении некоторые повторяющиеся вычисления могут быть устранены. Так, для шага вычисления центров кластеров величины <math>\mu_{ki}^m</math> могут вычисляться однократно и умножаться на <math>X_k</math> при включении в сумму, записанную в числителе. Для шага вычисления расстояний между центрами кластеров и точками, операция взятия квадратного корня не является обязательной, так как в дальнейшем на шаге вычисления степеней принадлежности можно непосредственно использовать квадраты этих расстояний, и сумма в знаменателе будет приобретать вид:

<math>\sum^{c}_{j=1} {\left ( \frac{D_{ki} ^ {2}}{D_{kj} ^ {2}} \right )}^{{1}/{m-1}}</math>

== Макроструктура алгоритма ==
Алгоритм включает в себя три основных этапа – вычисление центров кластеров, вычисление расстояний между центрами кластеров и точками данных (включающее в себя макрооперации вычитания векторов и вычисления их норм, как правило в Евклидовом пространстве) и пересчёт матрицы принадлежности.

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

Инициализация происходит случайным заполнением матрицы принадлежности <math>F</math> с соблюдением условия нормировки <math>\sum_{i=1}^c {\mu_{ki} =1}</math> и переходом к шагу 1, либо случайным определением центров кластеров <math>V_i</math> и переходом к шагу 2.

Далее осуществляются итерации следующего вида:

# <math>V_i=\frac{\sum_{k=1}^{M} {\mu_{ki}^m * X_k}}{\sum_{k=1}^{M} {\mu_{ki}^m} },i=\overline{1,c}</math>
# <math>D_{ki}=\sqrt{{\lVert X_k - V_i \rVert}^2},k=\overline{1,M},i=\overline{1,c}</math>
# <math>\mu_{ki}=\frac{1}{{ \sum^{c}_{j=1} {\left ( \frac{D_{ki}}{D_{kj}} \right )} }^{{2}/{m-1}}
},k=\overline{1,M},i=\overline{1,c}</math>

В конце каждой итерации проверяется условие останова вида <math>\max_{k = \overline{1,M},i = \overline{1,c}} {( \left | \mu_{ki} - \mu_{ki}^* \right |)} < \varepsilon</math>, либо <math>\max_{i = \overline{1,c}} {( \left | V_i - V_i^* \right |)} < \varepsilon</math>, где <math>\mu_{ki}^* (V_i^*)</math> – значение <math>\mu_{ki}(V_i)</math>, вычисленное на предыдущей итерации. Если условие не выполнено, осуществляется переход к шагу 1.

== Последовательная сложность алгоритма ==
При кластеризации <math>M</math> объектов данных, представленных точками в <math>\R^n</math>, на <math>c</math> кластеров, алгоритм Fuzzy C-Means в последовательном варианте имеет вычислительную сложность – <math>O(c^2 MI+cMnI)</math>, где <math>I</math> – число итераций. Если считать размерность данных <math>n</math> малой, то эта сложность сводится к <math>O(c^2 MI)</math>. Основной частью алгоритма в этом случае является пересчёт матрицы принадлежностей, требующий вычисления <math>cM</math> сумм из <math>c</math> слагаемых на каждой итерации.

== Информационный граф ==
Приведём граф единичной итерации алгоритма в параллельном оптимизированном варианте (метод распараллеливания взят в <ref>Kwok, T., Smith, K.,
Lozano, S., Taniar, D.: [http://num-meth.srcc.msu.ru/zhurnal/tom_2012/pdf/v13r207.pdf Parallel Fuzzy c-Means Clustering for Large Data Sets], последнее обращение 25.10.2016</ref>):

[[File:C-means_paralle_graph.png|thumb|upright=2.5|frame|center|alt=Paralel Fuzzy C-Means|Каждая вершина данного графа соответствует операциям из алгоритма, указанным при помощи указанных формул. Каждый из p столбцов соответствует работе одного из процессов. Пометки справа указывают число повторений каждого узла в ходе одной итерации.]]

Раздел 1.8 уточняет, соответствуют ли эти повторения однотипным ярусам или точкам данных, вычисления для которых можно распараллелить и далее.

Каждый процесс обладает следующими данными:
* координатами точек данных <math>X_k</math>, <math>k=\overline{1+rnk* \frac{M}{p},rnk*(\frac{M}{p}+1)}</math>, где <math>rnk</math> – номер процесса,
* значениями <math>\mu_{ki}</math> степени принадлежности для своих точек (<math>k=\overline{1+rnk* \frac{M}{p},rnk*(\frac{M}{p} +1)}, i=\overline{1,c}</math>),
* координатами центров кластеров <math>V_i</math>, <math>i=\overline{1,c}</math>.
Суммы <math>\sum_{k=1+rnk*\frac{M}{p}}^{rnk * ( \frac{M}{p} +1 )} {\mu_{ki}^m}</math> и <math>\sum_{k=1+rnk*\frac{M}{p}}^{rnk * ( \frac{M}{p} +1 )} {\mu_{ki}^m X_k}</math> вычисляются одновременно, поэтому значения <math>\mu_{ki}^m</math> вычисляются по одному разу за итерацию. Таким образом, второй ярус операций на рисунке на деле не содержит операций возведения в степень.
За счёт линейности большинства выражений относительно данных по точкам, процессы взаимодействуют только при редукции сумм, составляющих <math>V_i</math>. Всё остальное время каждый процессор работает только со своими <math>\frac{M}{p}</math> точками. Это обеспечивает применимость алгоритма для больших <math>M</math>.

== Ресурс параллелизма алгоритма ==
При распараллеливании по точкам исходных данных и условии останову по малому изменению степеней принадлежности выполнение одной итерации алгоритма FCM может быть разделено на следующие ярусы:
* <math>c</math> ярусов нахождения частичных сумм знаменателя (по <math>\frac{M}{p}-1</math> сложений, <math>\frac{M}{p}</math> операций возведения в степень на процесс),
* <math>c</math> ярусов нахождения частичных сумм числителя (по <math>\frac{M}{p} -1</math> сложений, <math>\frac{M}{p}</math> умножений на процесс),
* <math>2</math> редукции сумм и передач значений <math>V_i</math> процессам (получение <math>c(n+1)</math> значений, <math>cn</math> делений),
* <math>c</math> ярусов вычисления расстояний до центров (по <math>n-1</math> сложений, <math>n</math> вычитаний, <math>n</math> умножений), каждый процесс получает <math>\frac{M}{p}</math> точек на обработку,
* <math>c</math> ярусов вычисления степеней принадлежности точек (по <math>c+1</math> делений, c возведений в степень, <math>c-1</math> сложений), каждый процесс получает <math>\frac{M}{p}</math> точек на обработку,
* до <math>c</math> ярусов проверки условий останова (по <math>1</math> вычитанию, <math>1</math> сравнению), каждый процесс получает <math>\frac{M}{p}</math> точек на обработку,
* <math>1</math> редукция для обмена статусом завершения.
Таким образом, при распараллеливании по точкам исходных данных при условии наличия в каждом узле достаточного объёма памяти для хранения всего массива координат центров кластеров высота и ширина ЯПФ алгоритма FCM равны соответственно <math>O(c^2 I+cnI)</math> и <math>O(M)</math>.

== Входные и выходные данные алгоритма ==
'''Входные данные''': массив векторов <math>X_i</math>, число кластеров <math>c</math>, экспоненциальный вес <math>m\in{[1,\infty)}</math>, параметр останова <math>\varepsilon>0</math>.

'''Объём входных данных''': <math>Mn</math> для входных векторов, 3 вспомогательных параметра.

'''Выходные данные''': матрица принадлежности <math>F</math> (элементы <math>\mu_{ki}\in[0,1]</math>). Условие нормировки: <math>\sum^{c}_{i=1} {\mu_{ki}} = 1</math>.

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

== Свойства алгоритма ==
В случае неограниченного распараллеливания по точкам данных (1 процесс на точку), отношение последовательной сложности алгоритма к параллельной пропорционально <math>M</math>.

Параметр <math>m</math> задаёт степень «размытости» кластеров. В отсутствие априорных данных его обычно берут равным 2. В предельном случае сведения параметра <math>m</math> к значению 1, кластеры становятся чёткими и алгоритм вырождается в алгоритм кластеризации K-Means.

Алгоритм недетерминирован, начальное положение кластеров задаётся случайно либо явно, либо опосредованно (через матрицу принадлежности). Алгоритм сходится к локальному экстремуму <ref>Höppner, F., Klawonn, F.: [https://public.fh wolfenbuettel.de/~klawonn/Papers/hoeppnerklawonntfs03.pdf A Contribution to Convergence Theory of Fuzzy c-Means and Derivatives], Дата последнего обращения: 13.10.2016</ref> и, таким образом, не гарантирует оптимальный результат при случайном выборе начальных значений.

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

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

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

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

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

[[File:График.png|thumb|upright=2.5|frame|right|alt=Paralel Fuzzy C-Means time to iteration|График зависимости времени выполнения итерации параллельного нечеткого алгоритма С-средних (Fuzzy C-means) от количества процессоров и количества кластеризуемых вершин]]

[[File:Effect_parallel_fuzzy_c-means.png|thumb|upright=2.5|frame|right|alt=Paralel Fuzzy C-Means efficiency|График эффективности распараллеливания нечеткого алгоритма С-средних (Fuzzy C-means) в зависимости от количества процессоров и количества кластеризуемых вершин.]]

Исследование проведено на суперкомпьютере IBM Blue Gene/P<ref>[http://hpc.cs.msu.ru/bgp Описание вычислительного комплекса IBM Blue Gene/P]</ref>.
Для исследования была использована последовательная реализация алгоритма и реализован её [https://github.com/IllusiveMike/Parallel-Fuzzy-C-means/tree/patch-1 параллельный вариант]<ref>[https://github.com/nikmedoed/Parallel-Fuzzy-C-means Параллельная реализация алгоритма Fuzzy C-Means]</ref>.
Алгоритм обладает плохо исследованной сходимостью, но объем вычислений на итерации не зависит от значений данных, поэтому данное исследование масштабируемости было произведено для единичной итерации.

Для упрощения экспериментов было решено использовать количество вершин для кластеризации и количество процессов равное степени двойки, поэтому для каждого эксперимента были выбраны значения:
* <math>2^v, v=\overline{0,9}</math>, для количества процессоров;
* <math>2^w, w=\overline{10,20}</math>, для количества кластеризуемых вершин.

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

Полученные результаты говорят о хорошей масштабируемости реализации алгоритма. Для большинства экспериментов эффективность распараллеливания находится в пределах 100±3%. Высокая эффективность обуславливается тем, что данные равномерно распределены по процессорам и на каждой итерации требуется глобальная редукция всего <math>2c+1</math> значений (<math>c</math> значений числителей центроид кластеров, <math>c</math> значений знаменателей центроид кластеров и одно значение признака останова). Таким образом вычисления занимают значительно больше времени, чем взаимодействия между процессами, которые практически не приводят к простоям из-за хорошей балансировки. Спад эффективности при малом числе вершин и большом числе процессоров обуславливается тем, что с уменьшением числа вершин, обрабатываемых каждым процессором, растёт доля времени обмена данных между процессорами, не зависящего от числа вершин, как показано выше.

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

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

== Существующие реализации алгоритма ==
* пакет MATLAB <ref>[http://www.mathworks.com/help/fuzzy/fcm.html Документация пакета MATLAB, функция fcm], последнее обращение 15.10.2016</ref>
* Реализация алгоритма на POSTGRESQL <ref>[http://num-meth.srcc.msu.ru/zhurnal/tom_2012/pdf/v13r207.pdf Реализация алгоритма Fuzzy C-means на POSTGRESQL], последнее обращение 15.10.2016</ref>

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

[[en:Parallel Fuzzy c-Means Clustering]]

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

2016-11-21T07:17:32Z

Coctic:

= Статья [[Участник:Nikmedoed/Нечеткий алгоритм С-средних (Fuzzy C-means)]] =
* не указан вклад каждого автора [[Участник:Coctic|Coctic]] ([[Обсуждение участника:Coctic|обсуждение]]) 13:01, 25 октября 2016 (MSK)
** Могли бы вы подсказать в каком формате это сделать? Просто общее сообщение, либо в каждом пункте указать?
*** В начале написать "Авторы: Автор1 - раздел 1, Автор2 - раздел 2". Ну или что-то в том духе. [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 18:01, 28 октября 2016 (MSK)
:::: Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 13:32, 31 октября 2016 (MSK)

* п. 1.2 приведен набор формул, однако отсутствует пояснения, как эти формулы складываются в алгоритм [[Участник:Coctic|Coctic]] ([[Обсуждение участника:Coctic|обсуждение]]) 13:01, 25 октября 2016 (MSK)
** П. 1.2 расширен в соответствии с замечанием. Ожидаю отзыв. [[Участник:Illusive_mike|Дворецкий М.С.]] ([[Обсуждение участника:Illusive_mike|обсуждение]]) 15:46, 25 октября 2016 (MSK)
::: Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 13:32, 31 октября 2016 (MSK)
----------------
* п. 2.4. проведены исследования масштабируемости одной итерации. Исследование масштабируемости реализации в целом отсутствует [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 10:27, 17 ноября 2016 (MSK)
** Добавлено в статью: "Алгоритм обладает плохо исследованной сходимостью, но объем вычислений и итераций не зависит от значений данных, поэтому данное исследование масштабируемости было произведено для единичной итерации."
** Принято [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 12:41, 18 ноября 2016 (MSK)
* п. 2.4. Рис. 2 приведен график зависимости эффективности от параметров задачи. Не указано, о каком виде эффективности идет речь. Значение эффективности в 100% в реальности встречается очень редко, надо в тексте пояснить, почему такой хороший результат. [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 10:27, 17 ноября 2016 (MSK)
** Добавили пояснение, что это график временной эффективности
** Что такое временная эффективность? В [[Глоссарий|глоссарии]] такой нет. [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 12:41, 18 ноября 2016 (MSK)
*** Изменено на термин из глоссария - эффективность распараллеливания.
** Добавили пояснение про причину высокой временной эффективности
** Принято [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 16:40, 18 ноября 2016 (MSK)
* п. 2.4. ''Для большинства экспериментов эффективность находится в пределах 100±3%.''. Как эффективность может быть больше 100%? [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 10:27, 17 ноября 2016 (MSK)
** Сверхлинейное ускорение
** [https://www.dropbox.com/s/2ijzr6g8mhrftts/%D0%B8%D1%82%D0%BE%D0%B3%D0%B8%20%D1%82%D0%B5%D1%81%D1%82%D0%B0.xlsx?dl=0 Ссылка на расчёты]
** Доступная нам система профилировки недостаточна, чтобы найти причину сверхлинейного ускорения точно, поэтому мы не упомянули её прямым текстом
** Сначала надо разобраться, какая эффективность имеется в виду. [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 12:41, 18 ноября 2016 (MSK)
** Принято [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 16:40, 18 ноября 2016 (MSK)
* П. 2.4. Необходимо добавить описание ключей компилятора, особенностей запуска (раздел, используемые вычислительные узлы и т.п. информация, достаточная для воспроизведения данных). [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 16:40, 18 ноября 2016 (MSK)
** Добавлен файл README в проекте на GitHub. Это исправление мой товарищ сделал ещё 18, т.к. у меня не было доступа к чему-либо до вчера. А теперь обновил я ссылку.
** Принято [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 10:17, 21 ноября 2016 (MSK)

Участник:Nikmedoed/Нечеткий алгоритм С-средних (Fuzzy C-means)

2016-11-18T13:40:24Z

Coctic:

{{algorithm
| name = Нечеткий алгоритм С-средних (Fuzzy C-means)
| serial_complexity = <math>O(c^2 MI + cMnI), (I</math> - число итераций, <math>c</math> - количество кластеров, <math>M</math> - число точек, <math>n</math> - размерность точек (свойств на объект)<math>)</math>
| input_data = <math>Mn</math>
| output_data = <math>cM</math>
| pf_height = <math> O(c^2 I + cnI)</math>
| pf_width = <math>O( M )</math>
}}

Авторы: [[Участник:Nikmedoed|Н.А. Муромцев]] - перенос в вики, раздел 2, картинки, [[Участник:illusive_mike|М.С. Дворецкий]] - раздел 1

'''Нечеткий алгоритм С-средних''' (''Fuzzy C-means'') - позволяет получить нечёткую кластеризацию больших наборов числовых данных, что позволяет корректно определять объекты на границах кластеров. Однако, выполнение данного алгоритма требует серьёзных вычислительных ресурсов, а также изначального задания количества кластеров. Кроме того, может возникнуть неоднозначность с объектами, удалёнными от центров всех кластеров.

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

== Общее описание алгоритма ==
Алгоритм кластеризации Fuzzy C-Means (FCM) был предложен Дж. Данном в 1973 году <ref>Dunn, J.C.: A Fuzzy Relative of the ISODATA Process and Its Use in Detecting Compact Well-Separated Clusters. Journal of Cybernetics. 3 (1973): 32–57</ref> и доработан Дж. Бездеком в 1981 году <ref>Bezdek, J.C.: Pattern Recognition with Fuzzy Objective Function Algorithms. Plenum Press, New York (1981). ISBN 0-306-40671-3</ref>. В отличие от большинства существующих алгоритмов кластеризации, данный алгоритм является нечётким – каждый из объектов не входит однозначно в какой-либо кластер, а принадлежит всем кластерам с различными степенями принадлежности. Это даёт преимущества в качестве разбиения в случаях, когда кластеры находятся близко друг к другу, и большое число точек находится на их границах. Однако ценой такой нечёткости служат большие вычислительные затраты, чем у таких чётких алгоритмов, как [[Hard C-Means]] и [[K-Means]], при сохранении таких их недостатков, как априорное определение числа кластеров и отсутствие гарантии глобальной оптимальности результата.

== Математическое описание алгоритма ==
Исходные данные: массив объектов <math>{X_k}\in{\R^n}, k=\overline{1,M}</math>, число кластеров c, экспоненциальный вес <math>m\in{[1,\infty)}</math>, параметр останова <math>\varepsilon>0</math>.

Вычисляемые данные: матрица разбиения <math>F</math> размера <math>M\times c</math> (элементы <math>\mu_{ki}\in[0,1]</math>, <math>\sum^{c}_{i=1} {\mu_{ki}} = 1</math>), центры кластеров <math>V_i</math>, расстояния <math>D_{ki}</math> между объектами и центрами кластеров.

'''Формулы метода (вычисляются последовательно на каждой итерации):'''

1. Уточнение центров кластеров по степеням принадлежности
:<math>
\begin{align}
&V_i=\frac{\sum^{M}_{k=1} {\mu^m_{ki} * X_k}}{\sum^{M}_{k=1} {\mu^m_{ki}}},i=\overline{1,c}
\end{align}
</math>
2. Расчёт расстояний между новыми центрами кластеров и точками данных
:<math>
\begin{align}
&D_{ki}=\sqrt{{\lVert X_k - V_i \rVert}^2},k=\overline{1,M},i=\overline{1,c}
\end{align}
</math>
3. Пересчёт степеней принадлежности объектов кластерам
:<math>
\begin{align}
&\mu_{ki}=\frac{1}{{ \sum^{c}_{j=1} \left ( {\frac{D_{ki}}{D_{kj}}} \right ) }^{{2}/{m-1}}
},k=\overline{1,M},i=\overline{1,c}\\
\end{align}
</math>

На каждой итерации алгоритма происходит уточнение элементов матрицы <math>F</math>. Выходом алгоритма служит матрица <math>F</math>, к которой алгоритм сходится. Факт того, что алгоритм сошёлся, устанавливается проверкой вида <math>\max_{k = \overline{1,M},i = \overline{1,c}} {( \left | \mu_{ki} - \mu_{ki}^* \right |)} < \varepsilon</math> либо <math>\max_{i = \overline{1,c}} {( \left | V_i - V_i^* \right |)} < \varepsilon</math>, где <math>\mu_{ki}^* (V_i^*)</math> – значение <math>\mu_{ki}(V_i)</math>, вычисленное на предыдущей итерации.

== Вычислительное ядро алгоритма ==
Вычислительное ядро алгоритма Fuzzy C-Means составляют шаги вычисления центров кластеров, расстояний между ними и точками данных и в особенности пересчёта матрицы степеней принадлежности точек данных.

При реальном вычислении некоторые повторяющиеся вычисления могут быть устранены. Так, для шага вычисления центров кластеров величины <math>\mu_{ki}^m</math> могут вычисляться однократно и умножаться на <math>X_k</math> при включении в сумму, записанную в числителе. Для шага вычисления расстояний между центрами кластеров и точками, операция взятия квадратного корня не является обязательной, так как в дальнейшем на шаге вычисления степеней принадлежности можно непосредственно использовать квадраты этих расстояний, и сумма в знаменателе будет приобретать вид:

<math>\sum^{c}_{j=1} {\left ( \frac{D_{ki} ^ {2}}{D_{kj} ^ {2}} \right )}^{{1}/{m-1}}</math>

== Макроструктура алгоритма ==
Алгоритм включает в себя три основных этапа – вычисление центров кластеров, вычисление расстояний между центрами кластеров и точками данных (включающее в себя макрооперации вычитания векторов и вычисления их норм, как правило в Евклидовом пространстве) и пересчёт матрицы принадлежности.

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

Инициализация происходит случайным заполнением матрицы принадлежности <math>F</math> с соблюдением условия нормировки <math>\sum_{i=1}^c {\mu_{ki} =1}</math> и переходом к шагу 1, либо случайным определением центров кластеров <math>V_i</math> и переходом к шагу 2.

Далее осуществляются итерации следующего вида:

# <math>V_i=\frac{\sum_{k=1}^{M} {\mu_{ki}^m * X_k}}{\sum_{k=1}^{M} {\mu_{ki}^m} },i=\overline{1,c}</math>
# <math>D_{ki}=\sqrt{{\lVert X_k - V_i \rVert}^2},k=\overline{1,M},i=\overline{1,c}</math>
# <math>\mu_{ki}=\frac{1}{{ \sum^{c}_{j=1} {\left ( \frac{D_{ki}}{D_{kj}} \right )} }^{{2}/{m-1}}
},k=\overline{1,M},i=\overline{1,c}</math>

В конце каждой итерации проверяется условие останова вида <math>\max_{k = \overline{1,M},i = \overline{1,c}} {( \left | \mu_{ki} - \mu_{ki}^* \right |)} < \varepsilon</math>, либо <math>\max_{i = \overline{1,c}} {( \left | V_i - V_i^* \right |)} < \varepsilon</math>, где <math>\mu_{ki}^* (V_i^*)</math> – значение <math>\mu_{ki}(V_i)</math>, вычисленное на предыдущей итерации. Если условие не выполнено, осуществляется переход к шагу 1.

== Последовательная сложность алгоритма ==
При кластеризации <math>M</math> объектов данных, представленных точками в <math>\R^n</math>, на <math>c</math> кластеров, алгоритм Fuzzy C-Means в последовательном варианте имеет вычислительную сложность – <math>O(c^2 MI+cMnI)</math>, где <math>I</math> – число итераций. Если считать размерность данных <math>n</math> малой, то эта сложность сводится к <math>O(c^2 MI)</math>. Основной частью алгоритма в этом случае является пересчёт матрицы принадлежностей, требующий вычисления <math>cM</math> сумм из <math>c</math> слагаемых на каждой итерации.

== Информационный граф ==
Приведём граф единичной итерации алгоритма в параллельном оптимизированном варианте (метод распараллеливания взят в <ref>Kwok, T., Smith, K.,
Lozano, S., Taniar, D.: [http://num-meth.srcc.msu.ru/zhurnal/tom_2012/pdf/v13r207.pdf Parallel Fuzzy c-Means Clustering for Large Data Sets], последнее обращение 25.10.2016</ref>):

[[File:C-means_paralle_graph.png|thumb|upright=2.5|frame|center|alt=Paralel Fuzzy C-Means|Каждая вершина данного графа соответствует операциям из алгоритма, указанным при помощи указанных формул. Каждый из p столбцов соответствует работе одного из процессов. Пометки справа указывают число повторений каждого узла в ходе одной итерации.]]

Раздел 1.8 уточняет, соответствуют ли эти повторения однотипным ярусам или точкам данных, вычисления для которых можно распараллелить и далее.

Каждый процесс обладает следующими данными:
* координатами точек данных <math>X_k</math>, <math>k=\overline{1+rnk* \frac{M}{p},rnk*(\frac{M}{p}+1)}</math>, где <math>rnk</math> – номер процесса,
* значениями <math>\mu_{ki}</math> степени принадлежности для своих точек (<math>k=\overline{1+rnk* \frac{M}{p},rnk*(\frac{M}{p} +1)}, i=\overline{1,c}</math>),
* координатами центров кластеров <math>V_i</math>, <math>i=\overline{1,c}</math>.
Суммы <math>\sum_{k=1+rnk*\frac{M}{p}}^{rnk * ( \frac{M}{p} +1 )} {\mu_{ki}^m}</math> и <math>\sum_{k=1+rnk*\frac{M}{p}}^{rnk * ( \frac{M}{p} +1 )} {\mu_{ki}^m X_k}</math> вычисляются одновременно, поэтому значения <math>\mu_{ki}^m</math> вычисляются по одному разу за итерацию. Таким образом, второй ярус операций на рисунке на деле не содержит операций возведения в степень.
За счёт линейности большинства выражений относительно данных по точкам, процессы взаимодействуют только при редукции сумм, составляющих <math>V_i</math>. Всё остальное время каждый процессор работает только со своими <math>\frac{M}{p}</math> точками. Это обеспечивает применимость алгоритма для больших <math>M</math>.

== Ресурс параллелизма алгоритма ==
При распараллеливании по точкам исходных данных и условии останову по малому изменению степеней принадлежности выполнение одной итерации алгоритма FCM может быть разделено на следующие ярусы:
* <math>c</math> ярусов нахождения частичных сумм знаменателя (по <math>\frac{M}{p}-1</math> сложений, <math>\frac{M}{p}</math> операций возведения в степень на процесс),
* <math>c</math> ярусов нахождения частичных сумм числителя (по <math>\frac{M}{p} -1</math> сложений, <math>\frac{M}{p}</math> умножений на процесс),
* <math>2</math> редукции сумм и передач значений <math>V_i</math> процессам (получение <math>c(n+1)</math> значений, <math>cn</math> делений),
* <math>c</math> ярусов вычисления расстояний до центров (по <math>n-1</math> сложений, <math>n</math> вычитаний, <math>n</math> умножений), каждый процесс получает <math>\frac{M}{p}</math> точек на обработку,
* <math>c</math> ярусов вычисления степеней принадлежности точек (по <math>c+1</math> делений, c возведений в степень, <math>c-1</math> сложений), каждый процесс получает <math>\frac{M}{p}</math> точек на обработку,
* до <math>c</math> ярусов проверки условий останова (по <math>1</math> вычитанию, <math>1</math> сравнению), каждый процесс получает <math>\frac{M}{p}</math> точек на обработку,
* <math>1</math> редукция для обмена статусом завершения.
Таким образом, при распараллеливании по точкам исходных данных при условии наличия в каждом узле достаточного объёма памяти для хранения всего массива координат центров кластеров высота и ширина ЯПФ алгоритма FCM равны соответственно <math>O(c^2 I+cnI)</math> и <math>O(M)</math>.

== Входные и выходные данные алгоритма ==
'''Входные данные''': массив векторов <math>X_i</math>, число кластеров <math>c</math>, экспоненциальный вес <math>m\in{[1,\infty)}</math>, параметр останова <math>\varepsilon>0</math>.

'''Объём входных данных''': <math>Mn</math> для входных векторов, 3 вспомогательных параметра.

'''Выходные данные''': матрица принадлежности <math>F</math> (элементы <math>\mu_{ki}\in[0,1]</math>). Условие нормировки: <math>\sum^{c}_{i=1} {\mu_{ki}} = 1</math>.

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

== Свойства алгоритма ==
В случае неограниченного распараллеливания по точкам данных (1 процесс на точку), отношение последовательной сложности алгоритма к параллельной пропорционально <math>M</math>.

Параметр <math>m</math> задаёт степень «размытости» кластеров. В отсутствие априорных данных его обычно берут равным 2. В предельном случае сведения параметра <math>m</math> к значению 1, кластеры становятся чёткими и алгоритм вырождается в алгоритм кластеризации K-Means.

Алгоритм недетерминирован, начальное положение кластеров задаётся случайно либо явно, либо опосредованно (через матрицу принадлежности). Алгоритм сходится к локальному экстремуму <ref>Höppner, F., Klawonn, F.: [https://public.fh wolfenbuettel.de/~klawonn/Papers/hoeppnerklawonntfs03.pdf A Contribution to Convergence Theory of Fuzzy c-Means and Derivatives], Дата последнего обращения: 13.10.2016</ref> и, таким образом, не гарантирует оптимальный результат при случайном выборе начальных значений.

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

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

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

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

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

[[File:График.png|thumb|upright=2.5|frame|right|alt=Paralel Fuzzy C-Means time to iteration|График зависимости времени выполнения итерации параллельного нечеткого алгоритма С-средних (Fuzzy C-means) от количества процессоров и количества кластеризуемых вершин]]

[[File:Effect_parallel_fuzzy_c-means.png|thumb|upright=2.5|frame|right|alt=Paralel Fuzzy C-Means efficiency|График эффективности распараллеливания нечеткого алгоритма С-средних (Fuzzy C-means) в зависимости от количества процессоров и количества кластеризуемых вершин.]]

Исследование проведено на суперкомпьютере IBM Blue Gene/P<ref>[http://hpc.cs.msu.ru/bgp Описание вычислительного комплекса IBM Blue Gene/P]</ref>.
Для исследования была использована последовательная реализация алгоритма и реализован её [https://github.com/nikmedoed/Parallel-Fuzzy-C-means параллельный вариант]<ref>[https://github.com/nikmedoed/Parallel-Fuzzy-C-means Параллельная реализация алгоритма Fuzzy C-Means]</ref>.
Алгоритм обладает плохо исследованной сходимостью, но объем вычислений на итерации не зависит от значений данных, поэтому данное исследование масштабируемости было произведено для единичной итерации.

Для упрощения экспериментов было решено использовать количество вершин для кластеризации и количество процессов равное степени двойки, поэтому для каждого эксперимента были выбраны значения:
* <math>2^v, v=\overline{0,9}</math>, для количества процессоров;
* <math>2^w, w=\overline{10,20}</math>, для количества кластеризуемых вершин.

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

Полученные результаты говорят о хорошей масштабируемости реализации алгоритма. Для большинства экспериментов эффективность распараллеливания находится в пределах 100±3%. Высокая эффективность обуславливается тем, что данные равномерно распределены по процессорам и на каждой итерации требуется глобальная редукция всего <math>2c+1</math> значений (<math>c</math> значений числителей центроид кластеров, <math>c</math> значений знаменателей центроид кластеров и одно значение признака останова). Таким образом вычисления занимают значительно больше времени, чем взаимодействия между процессами, которые практически не приводят к простоям из-за хорошей балансировки. Спад эффективности при малом числе вершин и большом числе процессоров обуславливается тем, что с уменьшением числа вершин, обрабатываемых каждым процессором, растёт доля времени обмена данных между процессорами, не зависящего от числа вершин, как показано выше.

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

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

== Существующие реализации алгоритма ==
* пакет MATLAB <ref>[http://www.mathworks.com/help/fuzzy/fcm.html Документация пакета MATLAB, функция fcm], последнее обращение 15.10.2016</ref>
* Реализация алгоритма на POSTGRESQL <ref>[http://num-meth.srcc.msu.ru/zhurnal/tom_2012/pdf/v13r207.pdf Реализация алгоритма Fuzzy C-means на POSTGRESQL], последнее обращение 15.10.2016</ref>

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

[[en:Parallel Fuzzy c-Means Clustering]]

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

2016-11-18T13:40:12Z

Coctic:

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

2016-11-18T13:33:42Z

Coctic:

Участник:Gkhazeeva/Нечеткий алгоритм C средних

2016-11-18T13:32:29Z

Coctic:

{{algorithm
| name = Нечеткий алгоритм C средних
| serial_complexity = <math>O(Mdc^2i)</math>, <math>i</math> - количество итераций
| input_data = <math>M*d</math>, [количество наблюдений * размерность]
| output_data = <math>M*c</math>, [количество наблюдений * количество кластеров]
| pf_height = <math>2i</math>
| pf_width = <math>n</math>
}}

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

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

== Общее описание алгоритма ==
Кластеризация - это объединение объектов в группы (кластеры) на основе схожести признаков для объектов одной группы и отличий между группами. Нечеткий алгоритм C Средних (Fuzzy C-means, FCM) - алгоритм кластеризации, позволяющий объектам принадлежать с различной степенью нескольким кластерам одновременно. Впервые алгоритм был предложен J.C. Dunn в 1973 <ref>[http://www.tandfonline.com/doi/abs/10.1080/01969727308546046 | J. C. Dunn. A Fuzzy Relative of the ISODATA Process and Its Use in Detecting Compact Well-Separated Clusters. Journal of Cybernetics, volume 3,1973 - Issue 3, pp 32-57]</ref>. Нечеткое разбиение позволяет просто решить проблему объектов, расположенных на границе двух кластеров - им назначают степени принадлежностей равные 0.5.

Входные данные алгоритма: набор векторов, которые следует кластеризовать.

Параметры алгоритма: <math>c</math> - количество кластеров; <math>m</math> - экспоненциальный вес; <math>\varepsilon</math> - параметр останова алгоритма.

Выходные данные: матрица вероятностей принадлежности векторов кластерам.

Краткое описание алгоритма:

* Задать параметры алгоритма.

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

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

== Математическое описание алгоритма <ref>[http://it-claim.ru/Persons/Neyskiy/Article2_Neiskiy.pdf | Нейский И.М. Классификация и сравнение методов кластеризации.// Интеллектуальные технологии и системы. Сборник учебно-методических работ и статей аспирантов и студентов. – М.: НОК «CLAIM», 2006. – Выпуск 8. – С. 130-142.]</ref> ==

Пусть <math> W = w_{ij} \in[0,1],\; i = 1, ..., M, \; j = 1, ..., c</math> - матрица разбиения, где <math>w_{i,j}</math> - степень принадлежности объекта <math>i</math> к кластеру <math>j</math>; <math>c</math> - количество кластеров, <math>M</math> - количество векторов.

При этом элементы матрицы должны удовлетворять условиям:

* <math>\sum_{j = 1}^c w_{ij} = 1, i = 1, ..., M</math>                <math>(1)</math>
* <math>0 < \sum_{i = 1}^M w_{ij} < M, j = 1, ..., c</math>       <math>(2)</math>

Тогда алгоритм принимает следующий вид:

1) Задаем параметры алгоритма: <math>c</math> - количество кластеров; <math>m >= 1</math> - экспоненциальный вес, определяющий нечеткость кластеров; <math>\varepsilon > 0</math> - параметр останова алгоритма.

2) Генерируем случайным образом матрицу нечеткого разбиения с учетом условий <math>(1)</math> и <math>(2)</math>

3) Рассчитываем центроиды (центры кластеров): <math>V_j = {{\sum_{i=1}^M w_{ij}^m * X_i} \over {\sum_{i=1}^M w_{ij}^m}}, j = 1, ..., c</math>

4) Рассчитываем расстояния между объектами <math>X</math> и центроидами:

<math>D_{ij} = {||X_i - V_j||}, i = 1,...,M; j = 1,...,c </math>

5) Пересчет элементов матрицы разбиения:

при <math>D_{ij} >0</math> : <math>w_{ij} = {{1}\over {{ (\sum_{k=1}^c {{D_{ij}}\over{D_{ik}}} ) }^{2/(m-1)}}}, j = 1,...,c</math>

при <math>D_{ij} =0</math> : <math>w_{ij} = \delta_{ij}, j = 1,...,c</math>, где <math>\delta_{ij}</math> - символ Кронекера

6) Если <math>|| F - F^{*} || < \varepsilon </math>, где <math>F^{*}</math> - матрица нечеткого разбиения предыдущей итерации, то идем далее, иначе возвращаемся на пункт 3.

7) Конец.

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

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

* Поиск <math>V_j</math> - расчет центроидов (пункт 3 алгоритма)
* Нахождение <math>D_{ij}</math> - расстояний между объектами (пункт 4 алгоритма)
* Пересчет <math>w_{ij}</math> - элементов матрицы разбиения (пункт 5 алгоритма)

== Макроструктура алгоритма ==
Основные шаги при реализации алгоритма
* Генерация случайной матрицы размера <math>M</math> на где <math>c</math>, проверка условий
* Расчет центроидов – по сути, скалярное произведение с нормировкой
* Расчет расстояний – в общепринятом случае является скалярным произведением
* Пересчет матрицы – по сути, скалярное произведение
* Проверка условий останова – вычисление нормы

== Схема реализации последовательного алгоритма ==
float ** FuzzyCMeans (float** X, c, m, eps){
n = X.size();
r = X[0].size();
centers = generateZeroFill(c, r)
Wprev = genetateRandFill(n, c);
W = Wprev;
while (true){
// обновляем центры кластеров
for (int i=0; i<c; i++){
float * num = new float []();
float den = 0;
for (int j=0; j<n; j++){
num += pow(W[j][i], m) * X[j];
den+=pow(W[j][i], m);
}
centers[i] = num / den;
}
//обновляем вероятности W и считаем расстояние между матрицами W и Wprev
float max_diff = 0;
for (int i=0; i<n; i++)
for (int j=0; j<c; j++){
total = 0;
for (int m=0; m<с; m++)
total += pow(distance(X[i], centers[j]) / distance(X[i], centers[m]), 2/(m-1));
W[i][j] = 1/total;
max_diff = max(abs(Wprev[i][j]-W[i][j]), max_diff);
Wprev[i][j] = W[i][j];
}
if (max_diff < eps):
break;
}
return W;
}

== Последовательная сложность алгоритма ==
Последовательная сложность алгоритма состоит из сложности каждой итерации умноженной на их количество. Так как число итераций заранее неизвестно и зависит от входных параметров, рассмотрим сложность на каждой итерации. Наибольшую сложность представляет собой пересчет матрицы, сложность которого <math>O(c^2 nd)</math> (по сравнению со сложностью <math>O(cnd)</math> расчета расстояний, вычисления центроидов и проверки условия останова). Итого общая сложность алгоритма <math>O(c^2 ndi)</math>

== Информационный граф ==
Информационный граф представлен на рисунке ниже.

'''Первый ярус''' состоит из <math>M</math> параллельных операций 1, 2, совершаемых в цикле <math>c</math> раз для каждого кластера.

'''Операция 1''': <math>w_{ij}^m</math>, где <math>j</math> - номер итерации в цикле, <math>i</math> - номер параллельной ветви.

'''Операция 2''': <math>w_{ij}^m*X_i</math>

Здесь <math>j</math> - номер итерации в цикле, <math>i</math> - номер параллельной ветви.

На выходе из каждой ветки получаем вектор размера <math>1</math> x <math>c</math> и матрицу размера <math>d</math> x <math>c</math>.
Далее совершаем поэлементное сложение векторов и матриц соответственно, а затем делим каждый столбец в матрице на соответствующий элемент в векторе.

'''Второй ярус''' состоит их <math>M</math> параллельных операций 3, 4, 5 также совершаемых в цикле <math>c</math> раз.

'''Операция 3''': обновление значения <math>w_{ij}</math> по указанной в разделе 1.2 в пункте 5 формуле.

'''Операция 4''': <math>maximum = max(|w_{ij} - w_{ij}^{prev}|, maximum)</math>.

'''Операция 5''': <math>w_{ij}^{prev} = w_{ij}</math>.

Здесь <math>j</math> - номер итерации в цикле, <math>i</math> - номер параллельной ветви.

На выходе из каждой ветки получаем число <math>maximum</math>. Далее находим максимальное значение из полученных величин для каждой ветки. Затем проверяем условие останова алгоритма.

[[File:Scheme3.JPG]]

== Ресурс параллелизма алгоритма ==
Параллельная сложность алгоритма: <math>M*c^2*i</math>. Такая сложность получается за счет распараллеливания на каждом ярусе <math>M</math> операций. Иерархическая структура параллелизма подробно описана в [[#Информационный граф|п.1.7]].

В алгоритме не возникает скошенного параллелизма.

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

* Входные данные алгоритма: набор векторов <math>x_i</math> размерности <math>d</math>, где <math>i = 1,...,M</math>; <math>M</math> - количество векторов.
* Объем входных данных: <math>M*d</math> , [количество наблюдений * размерность].
* Выходные данные алгоритма: матрица вероятностей принадлежности векторов кластерам <math>M</math> на <math>c</math>.
* Объем выходных данных: <math>M*c</math> , [количество наблюдений * количество кластеров].

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

* Соотношение последовательной и параллельной формы алгоритма: <math>M</math>
* Вычислительная мощность: <math>{dc^2i} \over {c+d}</math>.
* Устойчивость: алгоритм не является устойчивым, поэтому существует много исследований о том, как первоначально выбрать параметры кластеризации.
* Сбалансированность: в данном алгоритме операция умножения доминирует над операцией сложения. Операции между параллельными ветвями сбалансированны.
* Детерминированность: алгоритм не является детерминированным, так как матрица нечеткого разбиение генерируется произвольно.
* Степень исхода вершины информационного графа ( для одной интерации): 2 (3 - с учетом, если выходные данные пошли на следующую итерацию).

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

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

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

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

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

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

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

* число процессоров [1 : 128];
* размер матрицы [10000 : 80000].

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

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

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

[[file: FuzzyCMeansPerformance.png |thumb|center|700px|Рисунок 1. Параллельная реализация нечеткого алгоритма С-средних. Изменение производительности в зависимости от числа процессоров и размера матрицы.]]
[[file: FuzzyCMeansEfficiency2.png|thumb|center|700px|Рисунок 2. Параллельная реализация нечеткого алгоритма С-средних. Изменение эффективности в зависимости от числа процессоров и размера матрицы.]]

Построим оценки масштабируемости выбранной реализации нечеткого алгоритма С-средних:
* По числу процессов: 0.007. При увеличении числа процессов эффективность на рассмотренной области изменений параметров запуска увеличивается.
* По размеру задачи: -0.0016. При увеличении размера задачи эффективность уменьшается.
* По двум направлениям: 0,000077. При рассмотрении увеличения как вычислительной сложности, так и числа процессов на всей рассмотренной области значений эффективность увеличивается, однако скорость увеличения эффективности небольшая.

Была использована следующая реализация алгоритма.

#include <mpi.h>
#include <stdio.h>
#include <iostream>
#include <stdlib.h>
#include <math.h>
#include <string.h>
#include <time.h>
using namespace std;
double **x; //input matrix of size (n x x_dim)
int n;
int x_dim;
double **centroids; //cluster centroids matrix of size (n_cluster x x_dim)
int n_cluster; // number of clusters
double **w; //probability matrix of size (n x n_cluster)
double **dist; //distances matrix of size (n x n_cluster)
double eps; //max error
double m; //parameter of algo
int max_iter; // max num of iterations
double **num;
double *den;
double *allden;
double *err;
double *total_err;
int rank, size;
double ** generateZerosMatrix(int r, int c){
double ** arr = new double* [r];
for (int i = 0; i < r; ++i){
arr[i] = new double[c]();
}
return arr;
}
int generate_data()
{
//generate matrix
x = generateZerosMatrix(n, x_dim);
centroids = generateZerosMatrix(n_cluster, x_dim);
w = generateZerosMatrix(n, n_cluster);
dist = generateZerosMatrix(n, n_cluster);
num = generateZerosMatrix(n_cluster, x_dim);
//generate vectors
den = new double [n_cluster]();
allden = new double [n_cluster]();
//for stopping algorithm
err = new double;
total_err = new double;
srand(time(0));
//initialize w randomly with restrictions
for (int i = 0; i < n; ++i){
double sum = 0;
for (int j = 0; j < n_cluster; ++j){
w[i][j] = rand();
sum += w[i][j];
}
for (int j = 0; j < n_cluster; ++j){
w[i][j] /= sum;
}
}
//initialize x randomly
for (int i = 0; i < n; ++i)
for (int j = 0; j < x_dim; ++j)
x[i][j] = rand();
return 0;
}
double make_iteration() {
// calculate centroids centers
for (int i = rank; i < n; i+=size)
for (int j = 0; j < n_cluster; ++j){
double mu = pow(w[i][j], m);
den[j] += mu;
for (int k = 0; k < x_dim; ++k)
num[j][k] = mu * x[i][k];
}
MPI_Allreduce(den, allden, n_cluster, MPI_DOUBLE, MPI_SUM, MPI_COMM_WORLD);
for (int j=0; j < n_cluster; ++j)
MPI_Allreduce(num[j], centroids[j], x_dim, MPI_DOUBLE, MPI_SUM, MPI_COMM_WORLD);
for (int i = 0; i < n_cluster; ++i)
for (int j = 0; j < x_dim; ++j)
centroids[i][j] /= allden[i];
// calculate distances and probabilities, check stop conditions
double err = 0.0;
for (int i = rank; i < n; i+=size)
for (int j = 0; j < n_cluster; ++j){
for (int k = 0; k < x_dim; ++k)
dist[i][j] += (x[i][k] - centroids[j][k]) * (x[i][k] - centroids[j][k]);
double w_prev = w[i][j];
for (int k = 0; k < n_cluster; ++k)
w[i][j] += dist[i][j] / dist[i][k];
w[i][j] = 1.0 / pow(w[i][j], 1.0 / (m - 1));
err = fmax(err, abs(w_prev - w[i][j]));
}
return err;
}
int FCM(){
*total_err = eps+1;
int cur_iter = 0;
while (cur_iter < max_iter && *total_err > eps){
*err = make_iteration();
MPI_Allreduce(err, total_err, 1, MPI_DOUBLE, MPI_MAX, MPI_COMM_WORLD);
cur_iter++;
}
return cur_iter;
}
void clearMatrix(double ** matr, int r, int c){
for (int i = 0; i < r; ++i){
delete [] matr[i];
}
delete [] matr;
}
int memory_free(){
clearMatrix(x, n, x_dim);
clearMatrix(centroids, n_cluster, x_dim);
clearMatrix(w, n_cluster, n);
clearMatrix(num, n_cluster, x_dim);
clearMatrix(dist, n, n_cluster);
delete [] den;
delete [] allden;
delete err;
delete total_err;
return 0;
}
int main(int argc, char **argv){
MPI_Init(&argc, &argv);
MPI_Comm_size(MPI_COMM_WORLD, &size);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
int n_repeat = strtol(argv[1], NULL, 10);
int nx_min = strtol(argv[2], NULL, 10);
int nx_max = strtol(argv[3], NULL, 10);
int step = strtol(argv[4], NULL, 10);
x_dim = strtol(argv[5], NULL, 10);
m = strtod(argv[6], NULL);
n_cluster = strtol(argv[7], NULL, 10);
max_iter = strtol(argv[8], NULL, 10);
eps = strtod(argv[9], NULL);
//for all input matrix sizes
for (n = nx_min; n <= nx_max; n += step){
double start, finish, time_elapsed_iter=0;
int total_iterations = 0;
//repeat for getting mean value
for (int i = 0; i < n_repeat; ++i) {
generate_data();
MPI_Barrier(MPI_COMM_WORLD);
start = MPI_Wtime();
total_iterations += FCM();
finish = MPI_Wtime();
memory_free();
time_elapsed_iter += (finish-start);
}
time_elapsed_iter /= total_iterations;
if (rank == 0) {
cout << n << " " << size << " " << time_elapsed_iter << endl;
}
}
MPI_Finalize();
}

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

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

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

* Реализация алгоритма на POSTGRESQL: http://num-meth.srcc.msu.ru/zhurnal/tom_2012/pdf/v13r207.pdf
* Библиотека для MATLAB: http://www.mathworks.com/help/fuzzy/fcm.html (распространяется на коммерческой основе)

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

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

2016-11-18T13:32:17Z

Coctic: /* Статья Нечеткий алгоритм C средних */

= Статья [[https://algowiki-project.org/ru/%D0%A3%D1%87%D0%B0%D1%81%D1%82%D0%BD%D0%B8%D0%BA:Gkhazeeva/%D0%9D%D0%B5%D1%87%D0%B5%D1%82%D0%BA%D0%B8%D0%B9_%D0%B0%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_C_%D1%81%D1%80%D0%B5%D0%B4%D0%BD%D0%B8%D1%85]] =
* Не указан вклад каждого автора [[Участник:Coctic|Coctic]] ([[Обсуждение участника:Coctic|обсуждение]]) 12:54, 25 октября 2016 (MSK)
** Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 10:55, 1 ноября 2016 (MSK)
* п. 1.2 номера формул следует выравнивать по правому краю, а не прилеплять вплотную к формуле [[Участник:Coctic|Coctic]] ([[Обсуждение участника:Coctic|обсуждение]]) 12:54, 25 октября 2016 (MSK)
** Условно исправлено. Форматирование сделано негодными средствами, но неясно, установлены ли средства (https://en.wikipedia.org/wiki/Help:Displaying_a_formula#Equation_numbering), чтобы сделать правильно [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 10:55, 1 ноября 2016 (MSK)
*** Пробовал сделать указанными Вами средствами - на этом ресурсе указанные Вами шаблоны не заработали [[Участник:Yushin|Павел Юшин]]
* п. 1.3 состоит из одного предложения и не дает достаточно информации [[Участник:Coctic|Coctic]] ([[Обсуждение участника:Coctic|обсуждение]]) 12:54, 25 октября 2016 (MSK)
** Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 10:55, 1 ноября 2016 (MSK)
* п. 1.7 приведенный рисунок не является информационным графом: не все дуги ориентированы, имеются циклы [[Участник:Coctic|Coctic]] ([[Обсуждение участника:Coctic|обсуждение]]) 12:54, 25 октября 2016 (MSK)
** Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 10:55, 1 ноября 2016 (MSK)
* п. 1.9 не приведено оценки объема входных и выходных данных [[Участник:Coctic|Coctic]] ([[Обсуждение участника:Coctic|обсуждение]]) 12:54, 25 октября 2016 (MSK)
** Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 10:55, 1 ноября 2016 (MSK)
* в разделе 2 отсутствуют необходимые пункты, п. 2.2 должен быть 2.7 [[Участник:Coctic|Coctic]] ([[Обсуждение участника:Coctic|обсуждение]]) 12:54, 25 октября 2016 (MSK)
** Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 10:55, 1 ноября 2016 (MSK)
* В списке литературы 1 ссылка - скопированный шаблон без реальной ссылки, 2 ссылка - просто URL без выходных данных источника [[Участник:Coctic|Coctic]] ([[Обсуждение участника:Coctic|обсуждение]]) 12:54, 25 октября 2016 (MSK)
** Исправлено частично. Ссылка 2 по-прежнему не имеет достаточных выходных данных [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 10:55, 1 ноября 2016 (MSK)
*** На сайте, где студентам выдавалось задание ( http://parallel.ru/ss16 ), данный материал предоставлялся в списке источников (номер [8]) в таком же виде, как он указан в данной статье [[Участник:Yushin|Павел Юшин]]
**** Не вижу никакого противоречия с тем, что я написал в замечании [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 10:47, 7 ноября 2016 (MSK)
**** Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 16:34, 13 ноября 2016 (MSK)

----
* п. 2.4. Приведен график зависимости эффективности от параметров задачи. Не указано, о какой конкретно эффективности идет речь. [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 10:29, 17 ноября 2016 (MSK)
** Была ссылка в справочный раздел с описанием эффективности
** Подпись под рисункам должна быть самодостаточна, без необходимости разбираться, куда была ссылка и какую ссылку искать. То же касается текста: он должен быть понятен без необходимости ходить по ссылкам, ссылки - средство предоставить дополнительную информацию, для уточнения деталей. [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 16:31, 18 ноября 2016 (MSK)

Участник:Ян-Мартин Тамм/Строгий алгоритм С средних

2016-11-18T11:15:57Z

Coctic:

{{algorithm
| name = Строгий алгоритм С средних (K-means, Hard C-Means)
| serial_complexity = <math>O(nkdi)</math>
| pf_height = <math>O(log_2(k)log_2(d)i)</math>
| pf_width = <math>O(nkd)</math>
| input_data = <math>nd+1</math>
| output_data = <math>nk</math>
}}
Автор: [[Участник:Darel|Ян-Мартин Тамм]]

= Свойства и структура алгоритма =
== Общее описание алгоритма ==
Строгий алгоритм C средних, более известный как K-средних, решает задачу разделения векторов в многомерном пространстве на заданное количество кластеров. При этом каждый вектор принадлежит только одному кластеру, поэтому алгоритм называется строгим, в то время как нечеткий алгоритм C средних (Fuzzy C-means, Soft K-means) определяет степень принадлежности вектора каждому из кластеров.
 
Данная задача является NP-трудной, тем не менее описываемый алгоритм сходится к локальному оптимуму. Глобальный оптимум не гарантируется и зависит от первоначального распределения центров кластеров и их количества. Общая идея алгоритма такова: фиксируем число кластеров <math>k</math>, произвольным образом выбираем центры кластеров, после чего повторяем следующие два действия, пока не будет выполнено условие остановки:
#Распределяем каждый вектор в ближайший кластер
#Пересчитываем значения центров как среднее значение координат векторов в каждом кластере
Минимизируется сумма расстояний векторов от центров их кластеров. Остановка производится если либо значение данной функции становится ниже некоторого порога, либо мало изменяется по сравнению с предыдущей итерацией.
== Математическое описание алгоритма ==
Дано множество d-мерных векторов  <math>U=\{u_1, u_2, ..., u_n\}</math> и число кластеров <math>k \in \mathbb{N}</math>. Требуется разбить множество <math>U</math> на <math>k</math> непересекающихся непустых кластеров <math>C_1, C_2, ..., C_k</math> таких, что <math>{\bigcup \limits _{i = 1}^k C_i} = U </math>.
 Для этого минимизируется функция <math>
J = \sum\limits_{i=1}^k J_i = \sum\limits_{i=1}^k \sum\limits_{ u \in C_i} \|u-c_i \|^2
</math>, где <math>c_i</math>— центр масс векторов кластера <math>C_i</math>. 
Произвольным образом инициализируем центры кластеров <math>c_1, c_2, ..., c_k</math>, после чего начинается основная часть алгоритма. 
<ul><li>Каждый вектор <math>u_l</math> определяем в ближайший к нему кластер <math>C_i</math>, то есть такой, что
<math>
\|u_l-c_i\|^2 \leqslant \|u_l-c_j\|^2 \;\; \forall i \neq j; \;\; (i,j=1,2,\ldots,k, \; l = 1,2,\ldots,n)
</math>.</li> Хранить информацию о принадлежности векторов кластерам будем в матрице <math>M</math> следующего вида:
:<math>
m_{ij} = \begin{cases}
1, & u_j \in C_i \\
0, & \text{otherwise}
\end{cases}
</math>
<li>Считаем значение функции <math>J</math> и прекращаем работу алгоритма, если это значение меньше заданного порога <math>\varepsilon</math>, либо значение мало изменилось после текущей итерации.</li>
<li>Обновляем значения центров кластеров
:<math>
c_i = \frac{1}{|C_i|} \sum\limits_{u \in C_i} u \;\; (i=1,2,\ldots,k)
</math></li>
<li>Возвращаемся к распределению векторов по кластерам.</li>
</ul>

== Вычислительное ядро алгоритма ==
Вычислительным ядром алгоритма является весь алгоритм, а именно два основных его шага:
<ul><li>Распределение векторов по кластерам</li><li>Пересчёт центров кластеров</li></ul>

== Макроструктура алгоритма ==
Как уже говорилось раньше, первоначальное распределение векторов по кластерам может быть произвольным, например, можно случайным образом выбрать <math>k</math> векторов из множества всех векторов <math>U</math>. 
Далее начинается цикл, его первая операция — распределение векторов по кластерам. В ней для каждого вектора считается расстояние от него, до каждого кластера <math>\rho = \big \| u - c \big \|^2=\sum_{i=1}^d (u_i-c_i)^2</math>, после чего из них выбирается наименьшее и заносится в матрицу. Подсчёт функции <math>J</math> можно проводить одновременно с первым шагом, так как в ней суммируются те же самые расстояния. Пересчёт центров кластеров — сумма всех векторов кластера, делённая на количество объектов в кластере. <math>
c = \frac{1}{|C|} \sum\limits_{u \in C} u
</math>

== Схема реализации последовательного алгоритма ==
<source lang="python">
def kmeans(points, k, cutoff):

# Pick out k random points to use as our initial centroids
initial = random.sample(points, k)

# Create k clusters using those centroids
clusters = [Cluster([p]) for p in initial]

# Loop through the dataset until the clusters stabilize
while True:
# Create a list of lists to hold the points in each cluster
lists = [ [] for c in clusters]

# For every point in the dataset ...
for p in points:
# Get the distance between that point and the centroid of the first cluster.
smallest_distance = getDistance(p, clusters[0].centroid)

# Set the cluster this point belongs to
clusterIndex = 0

# For the remainder of the clusters ...
for i in range(clusterCount - 1):
# calculate the distance of that point to each other cluster's centroid
distance = getDistance(p, clusters[i+1].centroid)
# If it's closer to that cluster's centroid update what we
# think the smallest distance is, and set the point to belong to that cluster
if distance < smallest_distance:
smallest_distance = distance
clusterIndex = i+1
lists[clusterIndex].append(p)

# Set our total_shift to zero for this iteration
total_shift = 0.0

# As many times as there are clusters ...
for i in range(k):
# Calculate how far the centroid moved in this iteration
shift = clusters[i].update(lists[i])
# Keep track of the total moves from all cluster centroid updates
total_shift += shift

# If the centroids have stopped moving much, we're done!
if total_shift < cutoff:
break
return clusters
</source>

== Последовательная сложность алгоритма ==
Распределение по кластерам — для каждого из <math>n</math> векторов и каждого из <math>k</math> кластеров посчитать расстояние, сложив <math>d</math> раз значения, на вычисление каждого из которых нужно 2 операции — <math>O(nkd)</math>. Пересчёт центров — <math>n</math> раз сложить и <math>k</math> раз поделить —  <math>O(n+k)</math>. На завершение алгоритма понадобится <math>i</math> итераций. Итого сложность <math>O(nkdi)</math>.

== Информационный граф ==
На рисунке ниже приведён информационный граф алгоритма. 
[[Файл:HCM graph1.png]]
 
Блок, определяющий ближайший кластер, подробнее. 
[[Файл:HCM_dist1.png]]

== Ресурс параллелизма алгоритма ==
Самой трудоёмкой операцией является распределение по кластерам. Так, для рассчёта расстояний, можно провести суммирование <math>d</math> элементов за <math>log_2(d)</math> операций. Расстояние от данного вектора до всех кластеров можно найти за одну операцию, после чего нужно найти наименьшее значение из <math>k</math> элементов за <math>log_2(k)</math> операций. И всё это нужно сделать для <math>n</math> векторов, что можно сделать параллельно за одну операцию. Для сходимости всё так же потребуется <math>i</math> итераций, общая сложность получается <math>O(log_2(k)log_2(d)i)</math>.

== Входные и выходные данные алгоритма ==
'''Входные данные:'''
*<math>U=\{u_1, u_2, ..., u_n\} \subset \mathbb{R}^d</math> — множество векторов
*<math>k \in \mathbb{N}</math> — количество кластеров
*<math>\varepsilon</math> — порог остановки ''(не обязательно)''.

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

'''Выходные данные:'''
*<math>M</math> — матрица принадлежности векторов кластерам размера <math>nk</math>. При этом данная матрица содержит только <math>n</math> единиц, остальные значения ноль. Возможен вывод в другом виде, например, список списков.

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

== Свойства алгоритма ==
<ul><li>Алгоритм не является детерминированным, так как инициализация кластеров происходит случайным образом, однако, ничто не мешает проводить инициализацию согласно некоторому детерминированному правилу.
</li><li>Алгоритм находит локальный оптимум, поэтому его обычно запускают несколько раз и выбирают лучший результат.</li><li>Вычислительная мощность <math>\frac{kdi}{k+d}</math></li><li>Алгоритм является устойчивым при одинаковой первоначальной инициализации — малая ошибка в начальных данных или при вычислениях очень незначительно повлияют на результат (скорее всего никак не повлияют). Тем не менее, при случайной инициализации результаты будут различны.</li><li>Прост в реализации и вычислениях</li></ul>

= Программная реализация алгоритма =
== Особенности реализации последовательного алгоритма ==
== Локальность данных и вычислений ==
== Возможные способы и особенности параллельной реализации алгоритма ==
== Масштабируемость алгоритма и его реализации ==
Для масштабируемости использовалась следующая [http://users.eecs.northwestern.edu/~wkliao/Kmeans/index.html параллельная реализация алгоритма] с использованием MPI. Тесты были проведены на компьютерной системе [http://hpc.cmc.msu.ru/bgp BlueGene], которая включает в себя 8192 процессорных ядра и имеет пиковую производительность 27.9 терафлопс.

Исследовалась сильная масштабируемость алгоритма. На графике видно, что алгоритм хорошо распараллеливается и достигается значительное ускорение. Рассчитывалось распределение десятимерных векторов на десять кластеров.
[[Файл:HCM_BlueGene.png]]

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

= Литература =
<ol><li>[http://faculty.petra.ac.id/resmana/private/fuzzy/nfmod.pdf Jan Jantzen «Neurofuzzy Modelling».(Электронное издание)] Technical University of Denmark, Department of Automation, Bldg 326, DK-2800 Lyngby, DENMARK.
Tech. report no 98-H-874 (nfmod), 30 Oct 1998. </li><li>Steinhaus H. (1956). Sur la division des corps materiels en parties. Bull. Acad. Polon. Sci., C1. III vol IV: 801—804.</li><li>Lloyd S. (1957). Least square quantization in PCM’s. Bell Telephone Laboratories Paper.</li><li>MacQueen J. (1967). Some methods for classification and analysis of multivariate observations. In Proc. 5th Berkeley Symp. on Math. Statistics and Probability, pages 281—297.</li></ol>

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

2016-11-18T11:15:42Z

Coctic:

Участник:Nikmedoed/Нечеткий алгоритм С-средних (Fuzzy C-means)

2016-11-18T09:41:34Z

Coctic:

{{algorithm
| name = Нечеткий алгоритм С-средних (Fuzzy C-means)
| serial_complexity = <math>O(c^2 MI + cMnI), (I</math> - число итераций, <math>c</math> - количество кластеров, <math>M</math> - число точек, <math>n</math> - размерность точек (свойств на объект)<math>)</math>
| input_data = <math>Mn</math>
| output_data = <math>cM</math>
| pf_height = <math> O(c^2 I + cnI)</math>
| pf_width = <math>O( M )</math>
}}

Авторы: [[Участник:Nikmedoed|Н.А. Муромцев]] - перенос в вики, раздел 2, картинки, [[Участник:illusive_mike|М.С. Дворецкий]] - раздел 1

'''Нечеткий алгоритм С-средних''' (''Fuzzy C-means'') - позволяет получить нечёткую кластеризацию больших наборов числовых данных, что позволяет корректно определять объекты на границах кластеров. Однако, выполнение данного алгоритма требует серьёзных вычислительных ресурсов, а также изначального задания количества кластеров. Кроме того, может возникнуть неоднозначность с объектами, удалёнными от центров всех кластеров.

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

== Общее описание алгоритма ==
Алгоритм кластеризации Fuzzy C-Means (FCM) был предложен Дж. Данном в 1973 году <ref>Dunn, J.C.: A Fuzzy Relative of the ISODATA Process and Its Use in Detecting Compact Well-Separated Clusters. Journal of Cybernetics. 3 (1973): 32–57</ref> и доработан Дж. Бездеком в 1981 году <ref>Bezdek, J.C.: Pattern Recognition with Fuzzy Objective Function Algorithms. Plenum Press, New York (1981). ISBN 0-306-40671-3</ref>. В отличие от большинства существующих алгоритмов кластеризации, данный алгоритм является нечётким – каждый из объектов не входит однозначно в какой-либо кластер, а принадлежит всем кластерам с различными степенями принадлежности. Это даёт преимущества в качестве разбиения в случаях, когда кластеры находятся близко друг к другу, и большое число точек находится на их границах. Однако ценой такой нечёткости служат большие вычислительные затраты, чем у таких чётких алгоритмов, как [[Hard C-Means]] и [[K-Means]], при сохранении таких их недостатков, как априорное определение числа кластеров и отсутствие гарантии глобальной оптимальности результата.

== Математическое описание алгоритма ==
Исходные данные: массив объектов <math>{X_k}\in{\R^n}, k=\overline{1,M}</math>, число кластеров c, экспоненциальный вес <math>m\in{[1,\infty)}</math>, параметр останова <math>\varepsilon>0</math>.

Вычисляемые данные: матрица разбиения <math>F</math> размера <math>M\times c</math> (элементы <math>\mu_{ki}\in[0,1]</math>, <math>\sum^{c}_{i=1} {\mu_{ki}} = 1</math>), центры кластеров <math>V_i</math>, расстояния <math>D_{ki}</math> между объектами и центрами кластеров.

'''Формулы метода (вычисляются последовательно на каждой итерации):'''

1. Уточнение центров кластеров по степеням принадлежности
:<math>
\begin{align}
&V_i=\frac{\sum^{M}_{k=1} {\mu^m_{ki} * X_k}}{\sum^{M}_{k=1} {\mu^m_{ki}}},i=\overline{1,c}
\end{align}
</math>
2. Расчёт расстояний между новыми центрами кластеров и точками данных
:<math>
\begin{align}
&D_{ki}=\sqrt{{\lVert X_k - V_i \rVert}^2},k=\overline{1,M},i=\overline{1,c}
\end{align}
</math>
3. Пересчёт степеней принадлежности объектов кластерам
:<math>
\begin{align}
&\mu_{ki}=\frac{1}{{ \sum^{c}_{j=1} \left ( {\frac{D_{ki}}{D_{kj}}} \right ) }^{{2}/{m-1}}
},k=\overline{1,M},i=\overline{1,c}\\
\end{align}
</math>

На каждой итерации алгоритма происходит уточнение элементов матрицы <math>F</math>. Выходом алгоритма служит матрица <math>F</math>, к которой алгоритм сходится. Факт того, что алгоритм сошёлся, устанавливается проверкой вида <math>\max_{k = \overline{1,M},i = \overline{1,c}} {( \left | \mu_{ki} - \mu_{ki}^* \right |)} < \varepsilon</math> либо <math>\max_{i = \overline{1,c}} {( \left | V_i - V_i^* \right |)} < \varepsilon</math>, где <math>\mu_{ki}^* (V_i^*)</math> – значение <math>\mu_{ki}(V_i)</math>, вычисленное на предыдущей итерации.

== Вычислительное ядро алгоритма ==
Вычислительное ядро алгоритма Fuzzy C-Means составляют шаги вычисления центров кластеров, расстояний между ними и точками данных и в особенности пересчёта матрицы степеней принадлежности точек данных.

При реальном вычислении некоторые повторяющиеся вычисления могут быть устранены. Так, для шага вычисления центров кластеров величины <math>\mu_{ki}^m</math> могут вычисляться однократно и умножаться на <math>X_k</math> при включении в сумму, записанную в числителе. Для шага вычисления расстояний между центрами кластеров и точками, операция взятия квадратного корня не является обязательной, так как в дальнейшем на шаге вычисления степеней принадлежности можно непосредственно использовать квадраты этих расстояний, и сумма в знаменателе будет приобретать вид:

<math>\sum^{c}_{j=1} {\left ( \frac{D_{ki} ^ {2}}{D_{kj} ^ {2}} \right )}^{{1}/{m-1}}</math>

== Макроструктура алгоритма ==
Алгоритм включает в себя три основных этапа – вычисление центров кластеров, вычисление расстояний между центрами кластеров и точками данных (включающее в себя макрооперации вычитания векторов и вычисления их норм, как правило в Евклидовом пространстве) и пересчёт матрицы принадлежности.

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

Инициализация происходит случайным заполнением матрицы принадлежности <math>F</math> с соблюдением условия нормировки <math>\sum_{i=1}^c {\mu_{ki} =1}</math> и переходом к шагу 1, либо случайным определением центров кластеров <math>V_i</math> и переходом к шагу 2.

Далее осуществляются итерации следующего вида:

# <math>V_i=\frac{\sum_{k=1}^{M} {\mu_{ki}^m * X_k}}{\sum_{k=1}^{M} {\mu_{ki}^m} },i=\overline{1,c}</math>
# <math>D_{ki}=\sqrt{{\lVert X_k - V_i \rVert}^2},k=\overline{1,M},i=\overline{1,c}</math>
# <math>\mu_{ki}=\frac{1}{{ \sum^{c}_{j=1} {\left ( \frac{D_{ki}}{D_{kj}} \right )} }^{{2}/{m-1}}
},k=\overline{1,M},i=\overline{1,c}</math>

В конце каждой итерации проверяется условие останова вида <math>\max_{k = \overline{1,M},i = \overline{1,c}} {( \left | \mu_{ki} - \mu_{ki}^* \right |)} < \varepsilon</math>, либо <math>\max_{i = \overline{1,c}} {( \left | V_i - V_i^* \right |)} < \varepsilon</math>, где <math>\mu_{ki}^* (V_i^*)</math> – значение <math>\mu_{ki}(V_i)</math>, вычисленное на предыдущей итерации. Если условие не выполнено, осуществляется переход к шагу 1.

== Последовательная сложность алгоритма ==
При кластеризации <math>M</math> объектов данных, представленных точками в <math>\R^n</math>, на <math>c</math> кластеров, алгоритм Fuzzy C-Means в последовательном варианте имеет вычислительную сложность – <math>O(c^2 MI+cMnI)</math>, где <math>I</math> – число итераций. Если считать размерность данных <math>n</math> малой, то эта сложность сводится к <math>O(c^2 MI)</math>. Основной частью алгоритма в этом случае является пересчёт матрицы принадлежностей, требующий вычисления <math>cM</math> сумм из <math>c</math> слагаемых на каждой итерации.

== Информационный граф ==
Приведём граф единичной итерации алгоритма в параллельном оптимизированном варианте (метод распараллеливания взят в <ref>Kwok, T., Smith, K.,
Lozano, S., Taniar, D.: [http://num-meth.srcc.msu.ru/zhurnal/tom_2012/pdf/v13r207.pdf Parallel Fuzzy c-Means Clustering for Large Data Sets], последнее обращение 25.10.2016</ref>):

[[File:C-means_paralle_graph.png|thumb|upright=2.5|frame|center|alt=Paralel Fuzzy C-Means|Каждая вершина данного графа соответствует операциям из алгоритма, указанным при помощи указанных формул. Каждый из p столбцов соответствует работе одного из процессов. Пометки справа указывают число повторений каждого узла в ходе одной итерации.]]

Раздел 1.8 уточняет, соответствуют ли эти повторения однотипным ярусам или точкам данных, вычисления для которых можно распараллелить и далее.

Каждый процесс обладает следующими данными:
* координатами точек данных <math>X_k</math>, <math>k=\overline{1+rnk* \frac{M}{p},rnk*(\frac{M}{p}+1)}</math>, где <math>rnk</math> – номер процесса,
* значениями <math>\mu_{ki}</math> степени принадлежности для своих точек (<math>k=\overline{1+rnk* \frac{M}{p},rnk*(\frac{M}{p} +1)}, i=\overline{1,c}</math>),
* координатами центров кластеров <math>V_i</math>, <math>i=\overline{1,c}</math>.
Суммы <math>\sum_{k=1+rnk*\frac{M}{p}}^{rnk * ( \frac{M}{p} +1 )} {\mu_{ki}^m}</math> и <math>\sum_{k=1+rnk*\frac{M}{p}}^{rnk * ( \frac{M}{p} +1 )} {\mu_{ki}^m X_k}</math> вычисляются одновременно, поэтому значения <math>\mu_{ki}^m</math> вычисляются по одному разу за итерацию. Таким образом, второй ярус операций на рисунке на деле не содержит операций возведения в степень.
За счёт линейности большинства выражений относительно данных по точкам, процессы взаимодействуют только при редукции сумм, составляющих <math>V_i</math>. Всё остальное время каждый процессор работает только со своими <math>\frac{M}{p}</math> точками. Это обеспечивает применимость алгоритма для больших <math>M</math>.

== Ресурс параллелизма алгоритма ==
При распараллеливании по точкам исходных данных и условии останову по малому изменению степеней принадлежности выполнение одной итерации алгоритма FCM может быть разделено на следующие ярусы:
* <math>c</math> ярусов нахождения частичных сумм знаменателя (по <math>\frac{M}{p}-1</math> сложений, <math>\frac{M}{p}</math> операций возведения в степень на процесс),
* <math>c</math> ярусов нахождения частичных сумм числителя (по <math>\frac{M}{p} -1</math> сложений, <math>\frac{M}{p}</math> умножений на процесс),
* <math>2</math> редукции сумм и передач значений <math>V_i</math> процессам (получение <math>c(n+1)</math> значений, <math>cn</math> делений),
* <math>c</math> ярусов вычисления расстояний до центров (по <math>n-1</math> сложений, <math>n</math> вычитаний, <math>n</math> умножений), каждый процесс получает <math>\frac{M}{p}</math> точек на обработку,
* <math>c</math> ярусов вычисления степеней принадлежности точек (по <math>c+1</math> делений, c возведений в степень, <math>c-1</math> сложений), каждый процесс получает <math>\frac{M}{p}</math> точек на обработку,
* до <math>c</math> ярусов проверки условий останова (по <math>1</math> вычитанию, <math>1</math> сравнению), каждый процесс получает <math>\frac{M}{p}</math> точек на обработку,
* <math>1</math> редукция для обмена статусом завершения.
Таким образом, при распараллеливании по точкам исходных данных при условии наличия в каждом узле достаточного объёма памяти для хранения всего массива координат центров кластеров высота и ширина ЯПФ алгоритма FCM равны соответственно <math>O(c^2 I+cnI)</math> и <math>O(M)</math>.

== Входные и выходные данные алгоритма ==
'''Входные данные''': массив векторов <math>X_i</math>, число кластеров <math>c</math>, экспоненциальный вес <math>m\in{[1,\infty)}</math>, параметр останова <math>\varepsilon>0</math>.

'''Объём входных данных''': <math>Mn</math> для входных векторов, 3 вспомогательных параметра.

'''Выходные данные''': матрица принадлежности <math>F</math> (элементы <math>\mu_{ki}\in[0,1]</math>). Условие нормировки: <math>\sum^{c}_{i=1} {\mu_{ki}} = 1</math>.

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

== Свойства алгоритма ==
В случае неограниченного распараллеливания по точкам данных (1 процесс на точку), отношение последовательной сложности алгоритма к параллельной пропорционально <math>M</math>.

Параметр <math>m</math> задаёт степень «размытости» кластеров. В отсутствие априорных данных его обычно берут равным 2. В предельном случае сведения параметра <math>m</math> к значению 1, кластеры становятся чёткими и алгоритм вырождается в алгоритм кластеризации K-Means.

Алгоритм недетерминирован, начальное положение кластеров задаётся случайно либо явно, либо опосредованно (через матрицу принадлежности). Алгоритм сходится к локальному экстремуму <ref>Höppner, F., Klawonn, F.: [https://public.fh wolfenbuettel.de/~klawonn/Papers/hoeppnerklawonntfs03.pdf A Contribution to Convergence Theory of Fuzzy c-Means and Derivatives], Дата последнего обращения: 13.10.2016</ref> и, таким образом, не гарантирует оптимальный результат при случайном выборе начальных значений.

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

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

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

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

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

[[File:График.png|thumb|upright=2.5|frame|right|alt=Paralel Fuzzy C-Means time to iteration|График зависимости времени выполнения итерации параллельного нечеткого алгоритма С-средних (Fuzzy C-means) от количества процессоров и количества кластеризуемых вершин]]

[[File:Effect_parallel_fuzzy_c-means.png|thumb|upright=2.5|frame|right|alt=Paralel Fuzzy C-Means efficiency|График временной эффективности параллельного нечеткого алгоритма С-средних (Fuzzy C-means) в зависимости от количества процессоров и количества кластеризуемых вершин.]]

Исследование проведено на суперкомпьютере IBM Blue Gene/P<ref>[http://hpc.cs.msu.ru/bgp Описание вычислительного комплекса IBM Blue Gene/P]</ref>.
Для исследования была использована последовательная реализация алгоритма и реализован её [https://github.com/nikmedoed/Parallel-Fuzzy-C-means параллельный вариант]<ref>[https://github.com/nikmedoed/Parallel-Fuzzy-C-means Параллельная реализация алгоритма Fuzzy C-Means]</ref>.
Алгоритм обладает плохо исследованной сходимостью, но объем вычислений и итераций не зависит от значений данных, поэтому данное исследование масштабируемости было произведено для единичной итерации.

Для упрощения экспериментов было решено использовать количество вершин для кластеризации и количество процессов равное степени двойки, поэтому для каждого эксперимента были выбраны значения:
* <math>2^v, v=\overline{0,9}</math>, для количества процессоров;
* <math>2^w, w=\overline{10,20}</math>, для количества кластеризуемых вершин.

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

Полученные результаты говорят о хорошей масштабируемости реализации алгоритма. Для большинства экспериментов эффективность находится в пределах 100±3%. Высокая эффективность обуславливается тем, что данные равномерно распределены по процессорам и на каждой итерации требуется глобальная редукция всего <math>2c+1</math> значений (<math>c</math> значений числителей центроид кластеров, <math>c</math> значений знаменателей центроид кластеров и одно значение признака останова). Таким образом вычисления занимают значительно больше времени, чем взаимодействия между процессами, которые практически не приводят к простоям из-за хорошей балансировки. Спад эффективности при малом числе вершин и большом числе процессоров обуславливается тем, что с уменьшением числа вершин, обрабатываемых каждым процессором, растёт доля времени обмена данных между процессорами, не зависящего от числа вершин, как показано выше.

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

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

== Существующие реализации алгоритма ==
* пакет MATLAB <ref>[http://www.mathworks.com/help/fuzzy/fcm.html Документация пакета MATLAB, функция fcm], последнее обращение 15.10.2016</ref>
* Реализация алгоритма на POSTGRESQL <ref>[http://num-meth.srcc.msu.ru/zhurnal/tom_2012/pdf/v13r207.pdf Реализация алгоритма Fuzzy C-means на POSTGRESQL], последнее обращение 15.10.2016</ref>

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

[[en:Parallel Fuzzy c-Means Clustering]]

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

2016-11-18T09:41:23Z

Coctic:

= Статья [[Участник:Nikmedoed/Нечеткий алгоритм С-средних (Fuzzy C-means)]] =
* не указан вклад каждого автора [[Участник:Coctic|Coctic]] ([[Обсуждение участника:Coctic|обсуждение]]) 13:01, 25 октября 2016 (MSK)
** Могли бы вы подсказать в каком формате это сделать? Просто общее сообщение, либо в каждом пункте указать?
*** В начале написать "Авторы: Автор1 - раздел 1, Автор2 - раздел 2". Ну или что-то в том духе. [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 18:01, 28 октября 2016 (MSK)
:::: Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 13:32, 31 октября 2016 (MSK)

* п. 1.2 приведен набор формул, однако отсутствует пояснения, как эти формулы складываются в алгоритм [[Участник:Coctic|Coctic]] ([[Обсуждение участника:Coctic|обсуждение]]) 13:01, 25 октября 2016 (MSK)
** П. 1.2 расширен в соответствии с замечанием. Ожидаю отзыв. [[Участник:Illusive_mike|Дворецкий М.С.]] ([[Обсуждение участника:Illusive_mike|обсуждение]]) 15:46, 25 октября 2016 (MSK)
::: Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 13:32, 31 октября 2016 (MSK)
----------------
* п. 2.4. проведены исследования масштабируемости одной итерации. Исследование масштабируемости реализации в целом отсутствует [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 10:27, 17 ноября 2016 (MSK)
** Добавлено в статью: "Алгоритм обладает плохо исследованной сходимостью, но объем вычислений и итераций не зависит от значений данных, поэтому данное исследование масштабируемости было произведено для единичной итерации."
** Принято [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 12:41, 18 ноября 2016 (MSK)
* п. 2.4. Рис. 2 приведен график зависимости эффективности от параметров задачи. Не указано, о каком виде эффективности идет речь. Значение эффективности в 100% в реальности встречается очень редко, надо в тексте пояснить, почему такой хороший результат. [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 10:27, 17 ноября 2016 (MSK)
** Добавили пояснение, что это график временной эффективности
** Что такое временная эффективность? В [[Глоссарий|глоссарии]] такой нет. [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 12:41, 18 ноября 2016 (MSK)
** Добавили пояснение про причину высокой временной эффективности
* п. 2.4. ''Для большинства экспериментов эффективность находится в пределах 100±3%.''. Как эффективность может быть больше 100%? [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 10:27, 17 ноября 2016 (MSK)
** Сверхлинейное ускорение
** [https://www.dropbox.com/s/2ijzr6g8mhrftts/%D0%B8%D1%82%D0%BE%D0%B3%D0%B8%20%D1%82%D0%B5%D1%81%D1%82%D0%B0.xlsx?dl=0 Ссылка на расчёты]
** Доступная нам система профилировки недостаточна, чтобы найти причину сверхлинейного ускорения точно, поэтому мы не упомянули её прямым текстом
** Сначала надо разобраться, какая эффективность имеется в виду. [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 12:41, 18 ноября 2016 (MSK)

Участник:Светлана Лукьяненко/Строгий алгоритм С средних (Hard C-Means, HCM)

2016-11-17T07:38:10Z

Coctic:

{{algorithm
| name = Строгий алгоритм С средних (Hard C-Means,HCM)
| serial_complexity = <math>O(N)</math>
| pf_height = <math>O(1)</math>
| pf_width = <math>O(N)</math>
| input_data = <math>nN+1</math>
| output_data = <math>C(N+n)</math>
}}

Авторы описания: [[Участник:Светлана_Лукьяненко|Лукьяненко Светлана]](1.1, 1.3, 1.4, 1.8, 1.10, 2.4, 2.7), [[Участник:Юрий_Комаров|Комаров Юрий]](1.2, 1.5, 1.6, 1.7, 1.8, 1.9, 2.4)

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

=== Общее описание алгоритма ===
'''Строгий алгоритм C средних''' ('''''Hard C-Means'''''; ''Jang, Sun and Mizutani, 1997''<ref>Jang, J.-S. R., Sun, C.-T. and Mizutani, E. (1997). Neuro-Fuzzy and Soft Computing, number
isbn 0-13-261066-3 in Matlab Curriculum Series, Prentice Hall, Upper Saddle River, NJ, USA.</ref>) позволяет распределить большие наборы числовых данных по кластерам в многомерном пространстве<ref>Jan Jantzen (1998). [http://faculty.petra.ac.id/resmana/private/fuzzy/nfmod.pdf Neurofuzzy Modelling.]</ref>. Алгоритм является управляемым, так как для работы с ним требуется задание одного параметра — числа кластеров, на которое необходимо разделить данные.
Входными данными для алгоритма являются набор векторов и количество кластеров, также может задаваться пороговое значение величины объектной функции, по достижении которого расчёт прекращается. Выходными данными для алгоритма является рядовая матрица, отображающая принадлежность исходных элементов построенным кластерам, и центры построенных кластеров.

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

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

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

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

==== Входные и выходные данные ====
На вход подаётся набор векторов <math>\{u_k\}_{k=1}^{N}</math> пространства <math>\mathbb{R}^n</math> и количество кластеров <math>C</math>.

Конечным результатом работы алгоритма являются построенная рядовая матрица <math>M</math>, содержащая информацию о принадлежности элементов кластерам:
:<math>
m_{ij} = \begin{cases}
1, & u_j \in C_i, \\
0, & \text{otherwise},
\end{cases}
</math>
где под <math>C_i</math> подразумевается <math>i</math>-ый построенный кластер, и набор <math>\{c_i\}_{i=1}^{C}</math> центров этих кластеров.

==== Описание алгоритма ====
Алгоритм состоит из 5 последовательных шагов.<ref>Нейский И. М. [http://it-claim.ru/Persons/Neyskiy/Article2_Neiskiy.pdf Классификация и сравнение методов кластеризации.] // Интеллектуальные технологии и системы. Сборник учебно-методических работ и статей аспирантов и студентов. – М.: НОК «CLAIM», 2006. – Выпуск 8. – С. 130-142.</ref>

'''Шаг 1'''

'''Инициализация кластерных центров''' <math>c_i \, (i=1,2,\ldots,C)</math> может происходить за счёт случайного выбора необходимого числа точек из входного набора либо путём явного указания.

'''Шаг 2'''

'''Вычисление рядовой матрицы''' <math>M = \|m_{ik}\|</math>, элементы которой задаются следующими выражениями (<math>N</math> — количество элементов во входном наборе данных):
:<math>
m_{ik} = \begin{cases}
1, & \|u_k-c_i\|^2 \leqslant \|u_k-c_j\|^2 \;\; \text{for all } i \neq j; \;\; (i,j=1,2,\ldots,C; \; k = 1,2,\ldots,N)\\
0, & \text{otherwise}.
\end{cases}
</math>


Будем говорить, что <math>u_k \in C_i</math>, если <math>m_{ik} = 1</math>.

'''Шаг 3'''

'''Расчёт объектной функции:'''
:<math>
J = \sum\limits_{i=1}^C J_i = \sum\limits_{i=1}^C \left( \sum\limits_{k:\, u_k \in C_i} \|u_k -c_i \|^2 \right)
.</math>

На этом шаге происходит '''остановка и выход из цикла''', если полученное значение ниже пороговой величины <math>\varepsilon_{tr}</math> или полученное значение не сильно отличается от значений, полученных на предыдущих циклах.

'''Шаг 4'''

'''Пересчёт кластерных центров''' выполняется в соответствии со следующим уравнением:
:<math>
c_i = \frac{1}{|C_i|} \sum\limits_{k:\, u_k \in C_i} u_k,
</math>
где под <math>|C_i|</math> подразумевается количество элементов в <math>i</math>-ом кластере.

'''Шаг 5'''

'''Переход по циклу''' на шаг 2.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма составляют вычисления квадратов нормы расстояния от каждого из векторов исходной выборки до промежуточных кластерных центров <math>\|u_k-c_i\|^2</math>. На каждой итерации алгоритма происходит расчёт <math>CN</math> таких расстояний.

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

<math>
d_{ki} = \|u_k-c_i\|^2
</math>

Также на шаге вычисления объектной функции производится множественное суммирование полученных расстояний:

<math>
J = \sum\limits_{i=1}^C J_i = \sum\limits_{i=1}^C \left( \sum\limits_{k:\, u_k \in C_i} \|u_k -c_i \|^2 \right),
</math>

а на шаге расчета кластерных центров происходит суммирование векторов:

<math>
c_i = \frac{1}{|C_i|} \sum\limits_{k:\, u_k \in C_i} u_k.
</math>

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

<source lang="pascal">
J = 0;
M = zeros(N,C);
for i = 1 to N //go through every element
d_min = MAXINT;
j_min = 1;
for j = 1 to C //deside which claster does element belong to
d_ij = sq_norm(u[i] - c[j]);
if d_ij < d_min
d_min = d_ij;
j_min = j;
//generation of output data
J += d_min;
M[i,j_min] = 1;
c_new[j] += u[i];
c_newCount[k]++;

</source>

=== Последовательная сложность алгоритма ===
На каждой итерации алгоритма требуется выполнение:
* <math>NC</math> операций вычисления квадрата нормы разности элементов;
* <math>NC</math> операций сравнения (вычитаний);
* <math>3N</math> операций сложения.

Каждая операция вычисления нормы разности векторов предполагает выполнение <math>2n-1</math> арифметических операций сложения и вычитания и <math>n</math> операций возведения в квадрат (умножений), поэтому получаем для каждой итерации:
* <math>(2nC + 3)N</math> арифметических операций сложения и вычитания;
* <math>nNC</math> операций умножения.

Ожидая, что предельная точность будет достигнута менее, чем за <math>N</math> итераций (в противном случае применение алгоритма можно считать нецелесообразным), получаем итоговую сложность последовательной реализации алгоритма <math>O(N)</math> (в предположении, что <math>n</math> и <math>C</math> существенно меньше <math>N</math>).

=== Информационный граф ===
Приведём аналитическое и графическое описание графа алгоритма.

Граф алгоритма состоит из 5 различных видов вершин.

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

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

'''Третья''' вершина отмечена символом '''''J''''', подразумевается, что на этом этапе происходит расчёт объектной функции.

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

'''Пятая''' соответствует операции пересчёта кластерных центров, она отмечена как '''''{c}'''''.

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

[[File:HardCMeans1.png|thumb|800px|center|Рисунок 1. Информационный граф алгоритма. Здесь '''''in''''' — ввод входных данных (<math>C</math> стартовых значений кластерных центров и 1 значение <math>u_i</math> на каждую вершину графа), '''''d''''' — вычисление минимального расстояния до кластерных центров (подробнее см. рисунок 2), '''''M''''' — запись единички в соответствующий столбец матрицы <math>M</math>, '''''J''''' — вычисление объектной функции по результатам полученных вычислений, '''''if''''' — проверка условия достижения заданной точности, '''''{c}''''' — пересчёт кластерных центров и '''''out''''' — вывод полученных данных (матрица <math>M</math> и <math>C</math> значений полученных кластерных центров).]]
[[File:HardCMeans2.PNG|thumb|400px|center|Рисунок 2. Подробное описание работы блока '''''d'''''. Здесь '''''in''''' — ввод входных данных (по 1 значению центра кластера на каждую из <math>C</math> соответствующих вершин графа и значение <math>u_i</math>, единое для этого '''''d'''''-блока), '''''d1,...,dC''''' — прямое вычисление расстояния до кластерных центров, '''''min''''' — вычисление минимума двух чисел (с сохранением соответствующего минимуму кластерного индекса) и '''''out''''' — вывод полученных данных (индекс кластерного центра, расположенного ближе всего к точке <math>u_i</math>, и соответствующее расстояние).]]

=== Ресурс параллелизма алгоритма ===
Для выполнения одной итерации алгоритма C средних необходимо выполнить параллельно ряд вычислений для каждого из <math>N</math> элементов:

# Вычисление <math>C</math> расстояний между элементом и кластерными центрами.
# Выполнение <math>(C - 1)</math> сравнений для определения минимального.
# Определение значений соответствующего рассматриваемому элементу <math>u_i</math> столбца матрицы <math>M</math>.

Эта последовательность операций может быть выполнена для каждого элемента <math>u_i</math> входной выборки независимо и поэтому составляет основной ресурс параллелизма алгоритма.

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

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

При этом, как легко видеть, ширина [[глоссарий#Ярусно-параллельная форма графа алгоритма|ЯПФ]] составляет <math>O(N)</math> (если быть точнее, просто <math>N</math>). Высота ЯПФ для строгого алгоритма C средних оценивается как <math>O(1)</math> (предполагаем, что число итераций существенно меньше объёма выборки <math>N</math>).

=== Входные и выходные данные алгоритма ===
'''Входные данные:'''
*<math>\{u_k\}_{k=1}^{N} \subset \mathbb{R}^n</math> — исходный набор векторов;
*<math>C</math> — количество кластеров (<math>2 \leqslant C \leqslant N</math>);
* ''(опционально)'' <math>\varepsilon_{tr}</math> — пороговая точность работы алгоритма.

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

'''Выходные данные:'''
*<math>M</math> — рядовая матрица из пространства <math>\mathbb{R}^{C \times N}</math>.
*<math>\{c_k\}_{k=1}^{C}</math> — набор построенных кластерных центров.

'''Объём выходных данных:''' <math>C(N+n)</math>.

=== Свойства алгоритма ===
'''Назначение:''' кластеризация больших наборов числовых данных.

'''Достоинства:'''
* лёгкость реализации;
* вычислительная простота.

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

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
==== Локальность реализации алгоритма ====
===== Структура обращений в память и качественная оценка локальности =====
===== Количественная оценка локальности =====
=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===
Исследуем масштабируемость параллельной реализации строгого алгоритма C средних, соответствующей последовательной реализации, описанной в [[#Схема реализации последовательного алгоритма|п1.5]]. Для проведения расчётов использовались ресурсы вычислительного комплекса IBM Blue Gene/P и собственная реализация алгоритма, поскольку в открытом доступе параллельные реализации алгоритма авторами найдены не были ([[#Существующие реализации алгоритма|п2.7]]).

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

* число процессоров <math>[16 : 256]</math> с шагом по степеням двойки;
* объём выборки <math>[10^3:10^7]</math> с шагом по степеням десятки;
* размерность системы <math>n=10</math>;
* количество кластеров <math>C = 11</math>.

В качестве изменяемого параметра для построения графика был выбран объём выборки <math>N</math>, поскольку варьирование прочих параметров существенно хуже отражает возможности применения технологии параллельных вычислений. Это связано с тем, что при малом количестве векторов время, затраченное на пересылку данных, сравнимо со временем, затрачиваемым непосредственно на расчёты; это хорошо видно на графике: при объёмах выборки, составляющих <math>10^3</math> и <math>10^4</math> векторов, использование большего числа процессоров не приводит к приросту производительности (наоборот, производительность падает) ввиду высоких накладных расходов.

[[file:HardCMeansPerfomance.png|thumb|center|700px|Рис.3 Реализация строгого алгоритма C средних. График производительности (GFLOPS) в зависимости от числа параллельных процессов и объёма выборки.]]

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

1) [https://github.com/artpar/Hard-Clustering-implementation Последовательная реализация на С++ ]

2) [http://projects.jasmeet.me/2013/03/HardCMeans.html Последовательная реализация на MatLab ]

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

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

Обсуждение участника:Светлана Лукьяненко

2016-11-17T07:38:02Z

Coctic:

Участник:Каледа Александр/Строгий алгоритм С средних (Hard C-Means)

2016-11-17T07:35:13Z

Coctic:

{{algorithm
| name = Строгий алгоритм С средних (Hard C-Means)
| serial_complexity = <math>O(n)</math>
| pf_height = <math>O(1)</math>
| pf_width = <math>O(n)</math>
| input_data = <math>nm+1</math>
| output_data = <math>(n+m)C</math>
}}

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

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

=== Общее описание алгоритма ===
'''Строгий алгоритм C средних''' ('''''Hard C-Means, HCM'''''; ''Jang, Sun and Mizutani, 1997'') один из наиболее широко используемых алгоритмов кластеризации данных<ref>[http://faculty.petra.ac.id/resmana/private/fuzzy/nfmod.pdf Jantzen J. Neurofuzzy Modelling. 1998. Электронное издание. 28 Стр.]</ref>. Алгоритм разбивает большие наборы векторов в многомерном пространстве по заранее заданному количеству кластеров (т.е. является управляемым).

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

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

Вычисления, выполняющиеся на очередной итерации алгоритма:

# Расчёт рядовой матрицы (сопоставление вектора соответствующему кластерному центру).
# Расчёт объектной функции.
# Пересчёт кластерных центров.

=== Математическое описание алгоритма ===
Исходные данные: матрица <math>U\in \mathbb{R}^{n\times m}</math>, представляющая собой набор векторов <math>\{u_i\}_{i=1}^{n}, u_i \in \mathbb{R}^m</math>; количество кластеров <math>C \in \mathbb{N}</math>.

Вычисляемые данные: набор векторов - кластерных центров <math>\{c_i\}_{i=1}^{C}, c_i \in \mathbb{R}^m</math>; матрица <math>M\in \mathbb{N}^{n\times C}</math> c информацией о разбиении объектов на кластера. Элемент <math>m_{ij}=1</math>, если <math>u_j \in C_i</math>, где <math>C_i</math> содержит все объекты <math>u</math>, принадлежащие кластеру <math>i</math>. Остальные элементы <math>m_{ij}=0</math>.

Алгоритм:

Шаг 1. Инициализация кластерных центров <math>c_i, i = 1, 2, \dots, C.</math> Это можно сделать выбрав случайным образом C векторов из входного набора <math>\{u_i\}_{i=1}^{n}</math>

Шаг 2. Вычисление рядовой матрицы M.

Матрица <math>M</math> состоит из элементов <math>M = \|m_{ik}\|</math>.

:<math>
m_{ik} = \begin{cases}
1, & \|u_k-c_i\|^2 \leqslant \|u_k-c_j\|^2 \;\; \text{for all } i \neq j; \;\; (i,j=1,2,\ldots,C; \; k = 1,2,\ldots,n)\\
0, & \text{otherwise}.
\end{cases}
</math>

Шаг 3. Расчет объектной функции:

:<math>
J = \sum\limits_{i=1}^C J_i = \sum\limits_{i=1}^C \left( \sum\limits_{k:\, u_k \in C_i} \|u_k -c_i \|^2 \right)</math>.

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

Шаг 4. Пересчет кластерных центров.

Пересчет кластерных центров выполняется в соответствии со следующим уравнением:
:<math>
c_i = \frac{1}{|C_i|} \sum\limits_{k:\, u_k \in C_i} u_k,
</math>
где <math>|C_i|</math> -- количество элементов в <math>i</math>-ом кластере.

Шаг 5. Переход на шаг 2.

Описание взято из <ref>[http://it-claim.ru/Persons/Neyskiy/Article2_Neiskiy.pdf Нейский И.М. Классификация и сравнение методов кластеризации // Интеллектуальные технологии и системы. Сборник учебно-методических работ и статей аспирантов и студентов. – М.: НОК «CLAIM», 2006. – Выпуск 8. – С. 130-142.]</ref>.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма Hard C-Means можно составить из множественных (всего их <math>nC</math>) вычислений квадратов нормы разности векторов <math>u_k</math> и кластерных центров <math>c_i</math>: <math>\|u_k-c_i\|^2</math>.

=== Макроструктура алгоритма ===
Как записано и в описании ядра алгоритма, основную часть метода составляют множественные (<math>Cn</math>) вычисления квадратов норм:

:<math>\|u_k-c_i\|^2</math>.

Также присутствуют данные вычислительные операции:

* Суммирование квадратов норм векторов:

:<math>
J = \sum\limits_{i=1}^C J_i = \sum\limits_{i=1}^C \left( \sum\limits_{k:\, u_k \in C_i} \|u_k -c_i \|^2 \right)
</math>

* Поэлементное суммирование векторов:

:<math>
c_i = \frac{1}{|C_i|} \sum\limits_{k:\, u_k \in C_i} u_k
</math>

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

<source lang="python3">
for i in range(n):
idx_min = 0
dist_min = ((u[i] - c[0]) ** 2).sum()

for j in range(1, C):
dist = ((u[i] - c[j]) ** 2).sum()
if dist < dist_min:
idx_min = j
dist_min = dist

M[i, idx_min] = 1
c_next[idx_min] += u[i]
c_next_cnt[idx_min] += 1
J += dist_min
</source>

=== Последовательная сложность алгоритма ===
Предполагаем, что предельная точность алгоритма достигаема менее, чем за <math>n</math> итераций. Иначе использование алгоритма можно считать нерациональным. Также предположим, что размерность <math>m</math> и количество кластерных центров <math>C</math> существенно меньше <math>n</math>.

Операция вычисления квадрата нормы разности векторов требует выполнения <math>m-1</math> арифметических операций сложения, <math>m</math> операций вычитания и <math>m</math> операций умножения.

Каждая итерация алгоритма требует выполнения:
* <math>nC</math> операций вычисления квадрата нормы разности векторов;
* <math>nC</math> операций сравнения квадрата нормы;
* <math>3n</math> операций сложения;

Таким образом, на каждой итерации имеем:
* <math>mnC</math> операций умножения;
* <math>(2mC + 3)n</math> арифметических операций сложения и вычитания;

В итоге имеем сложность последовательной реализации алгоритма <math>O(n)</math>.

=== Информационный граф ===
Граф алгоритма состоит из 4 видов вершин:

'''Первая''' группа вершин отмечена символом '''''M'''''. Ей соответствует вычисление минимального расстояния до кластерных центров, а также запись единицы в соответствующий столбец матрицы, обозначающей принадлежность кластерному центру:
* независимое вычисление расстояний от заданного элемента <math>u_i</math> до каждого из кластерных центров;
* последовательное сравнение полученных значений с целью отыскания максимума;
* операция записи 1 в соответствующий столбец матрицы принадлежности кластерным центрам;

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

'''Третья''' вершина помечена '''''if''''', на этом этапе происходит проверка условия достижения требуемой точности.

'''Четвертая''' соответствует операции пересчёта кластерных центров, она отмечена как '''''C'''''.

[[File:Cmeans.png|thumb|800px|center|Рисунок 1. Информационный граф алгоритма. Здесь '''''in''''' — ввод входных данных, '''''D''''' — вычисление минимального расстояния до кластерных центров и проставление принадлежности соответствующему кластерному центру, '''''J''''' — вычисление объектной функции по результатам полученных вычислений, '''''if''''' — проверка условия достижения желаемой точности, '''''C''''' — пересчёт кластерных центров и '''''out''''' — вывод полученных данных.]]

=== Ресурс параллелизма алгоритма ===
Основной ресурс параллелизма алгоритма составляет итерационный блок. Эта последовательность итераций может быть выполнена для каждого входного вектора <math>u_i</math> независимо. Однако, в конце выполнения каждого итерационного блока имеют место последовательные вычисления - сложение значений объектной функции, полученных независимо на каждом процессоре, а также перерасчет кластерных центров.

Высота [[глоссарий#Ярусно-параллельная форма графа алгоритма|ЯПФ]] оценивается как <math>O(1)</math> (при условии, что число итераций существенно меньше объёма выборки <math>n</math>). Ширина [[глоссарий#Ярусно-параллельная форма графа алгоритма|ЯПФ]] равна <math>n</math>.

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

=== Входные и выходные данные алгоритма ===
'''Входные данные:''' матрица <math>U\in \mathbb{R}^{n\times m}</math>, представляющая собой набор векторов <math>\{u_i\}_{i=1}^{n}, u_i \in \mathbb{R}^m</math>; количество кластеров <math>C \in \mathbb{N}</math>.

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

'''Выходные данные:''' набор векторов - кластерных центров <math>\{c_i\}_{i=1}^{C}, c_i \in \mathbb{R}^m</math>; матрица <math>M\in \mathbb{N}^{n\times C}</math> c информацией о разбиении объектов на кластера. Элемент <math>m_{ij}=1</math>, если <math>u_j \in C_i</math>, где <math>C_i</math> содержит все объекты <math>u</math>, принадлежащие кластеру <math>i</math>. Остальные элементы <math>m_{ij}=0</math>.

'''Объём выходных данных:''' <math>(n+m)C</math>.

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

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

Недостатки:

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

Соотношение последовательной и параллельной сложности алгоритма: линейное.

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

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

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

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

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

==== Масштабируемость алгоритма ====
==== Масштабируемость реализации алгоритма ====
Проведём исследование масштабируемости параллельной реализации строгого алгоритма C средних согласно [[Scalability methodology|методике]].

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

* число процессоров [1 : 48] с шагом 1;
* размерность пространства [3 : 50] c шагом 3;
* число векторов 100 000 000;
* число кластерных центров 30;

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

* минимальная эффективность реализации 0.014;
* максимальная эффективность реализации 0.9.

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

[[file:GFLOPS_AA.png|thumb|center|700px|Рисунок 2. Параллельная реализация алгоритма. Изменение производительности в зависимости от числа процессоров и размерности векторов.]]
[[file:EFFICIENCY.png|thumb|center|700px|Рисунок 3. Параллельная реализация алгоритма. Изменение эффективности в зависимости от числа процессоров и размерности векторов.]]

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

=== Существующие реализации алгоритма ===
* [http://projects.jasmeet.me/2013/03/HardCMeans.html Последовательная реализация алгоритма на MatLab]
* [https://github.com/artpar/Hard-Clustering-implementation Последовательная реализация алгоритма на С++]

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

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

2016-11-17T07:35:02Z

Coctic:

= Статья [[Участник:Каледа Александр/Строгий алгоритм С средних (Hard C-Means)]] =
* Не указан вклад каждого автора [[Участник:Coctic|Coctic]] ([[Обсуждение участника:Coctic|обсуждение]]) 11:08, 25 октября 2016 (MSK)
** Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 12:42, 2 ноября 2016 (MSK)
* Стоит добавить ссылку на оригинальную публикацию, в которой был впервые предложен алгоритм. [[Участник:Coctic|Coctic]] ([[Обсуждение участника:Coctic|обсуждение]]) 11:08, 25 октября 2016 (MSK)
** Не исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 12:42, 2 ноября 2016 (MSK)
* Значительная часть п. 1.2 совпадает с тем же пунктом из [[Строгий алгоритм С средних (Hard C-Means, HCM)]]
** Замечание снимается [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 12:42, 2 ноября 2016 (MSK)
* Пункты раздела 2 не соответствуют шаблону. П. 2.1 должен быть 2.4, п. 2.2 должен быть 2.7, остальные пункты пропущены [[Участник:Coctic|Coctic]] ([[Обсуждение участника:Coctic|обсуждение]]) 11:08, 25 октября 2016 (MSK)
** Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 12:42, 2 ноября 2016 (MSK)
* В списке литературы отсутствуют выходные данные публикаций, кроме названия и автора. По приведенным данным определить конкретную публикацию не представляется возможным. [[Участник:Coctic|Coctic]] ([[Обсуждение участника:Coctic|обсуждение]]) 11:08, 25 октября 2016 (MSK)
** Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 12:42, 2 ноября 2016 (MSK)
* Список литературы совпадает со списком из [[Строгий алгоритм С средних (Hard C-Means, HCM)]] [[Участник:Coctic|Coctic]] ([[Обсуждение участника:Coctic|обсуждение]]) 11:08, 25 октября 2016 (MSK)
** Замечание снимается [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 12:42, 2 ноября 2016 (MSK)

------------
* Стоит добавить ссылку на оригинальную публикацию, в которой был впервые предложен алгоритм [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 12:42, 2 ноября 2016 (MSK)
* п. 2.4.1 пустой. [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 10:35, 17 ноября 2016 (MSK)
* п. 2.4.2. Отсутствует ссылка на текст исследуемой программы и аппаратную платформу, на которой проводилось тестирование. [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 10:35, 17 ноября 2016 (MSK)
* Рис. 3. В подписи к рисунку не указано, график зависимости эффективности какого типа приведен. [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 10:35, 17 ноября 2016 (MSK)

Участник:Gkhazeeva/Нечеткий алгоритм C средних

2016-11-17T07:29:18Z

Coctic:

{{algorithm
| name = Нечеткий алгоритм C средних
| serial_complexity = <math>O(Mdc^2i)</math>, <math>i</math> - количество итераций
| input_data = <math>M*d</math>, [количество наблюдений * размерность]
| output_data = <math>M*c</math>, [количество наблюдений * количество кластеров]
| pf_height = <math>2i</math>
| pf_width = <math>n</math>
}}

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

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

== Общее описание алгоритма ==
Кластеризация - это объединение объектов в группы (кластеры) на основе схожести признаков для объектов одной группы и отличий между группами. Нечеткий алгоритм C Средних (Fuzzy C-means, FCM) - алгоритм кластеризации, позволяющий объектам принадлежать с различной степенью нескольким кластерам одновременно. Впервые алгоритм был предложен J.C. Dunn в 1973 <ref>[http://www.tandfonline.com/doi/abs/10.1080/01969727308546046 | J. C. Dunn. A Fuzzy Relative of the ISODATA Process and Its Use in Detecting Compact Well-Separated Clusters. Journal of Cybernetics, volume 3,1973 - Issue 3, pp 32-57]</ref>. Нечеткое разбиение позволяет просто решить проблему объектов, расположенных на границе двух кластеров - им назначают степени принадлежностей равные 0.5.

Входные данные алгоритма: набор векторов, которые следует кластеризовать.

Параметры алгоритма: <math>c</math> - количество кластеров; <math>m</math> - экспоненциальный вес; <math>\varepsilon</math> - параметр останова алгоритма.

Выходные данные: матрица вероятностей принадлежности векторов кластерам.

Краткое описание алгоритма:

* Задать параметры алгоритма.

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

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

== Математическое описание алгоритма <ref>[http://it-claim.ru/Persons/Neyskiy/Article2_Neiskiy.pdf | Нейский И.М. Классификация и сравнение методов кластеризации.// Интеллектуальные технологии и системы. Сборник учебно-методических работ и статей аспирантов и студентов. – М.: НОК «CLAIM», 2006. – Выпуск 8. – С. 130-142.]</ref> ==

Пусть <math> W = w_{ij} \in[0,1],\; i = 1, ..., M, \; j = 1, ..., c</math> - матрица разбиения, где <math>w_{i,j}</math> - степень принадлежности объекта <math>i</math> к кластеру <math>j</math>; <math>c</math> - количество кластеров, <math>M</math> - количество векторов.

При этом элементы матрицы должны удовлетворять условиям:

* <math>\sum_{j = 1}^c w_{ij} = 1, i = 1, ..., M</math>                <math>(1)</math>
* <math>0 < \sum_{i = 1}^M w_{ij} < M, j = 1, ..., c</math>       <math>(2)</math>

Тогда алгоритм принимает следующий вид:

1) Задаем параметры алгоритма: <math>c</math> - количество кластеров; <math>m >= 1</math> - экспоненциальный вес, определяющий нечеткость кластеров; <math>\varepsilon > 0</math> - параметр останова алгоритма.

2) Генерируем случайным образом матрицу нечеткого разбиения с учетом условий <math>(1)</math> и <math>(2)</math>

3) Рассчитываем центроиды (центры кластеров): <math>V_j = {{\sum_{i=1}^M w_{ij}^m * X_i} \over {\sum_{i=1}^M w_{ij}^m}}, j = 1, ..., c</math>

4) Рассчитываем расстояния между объектами <math>X</math> и центроидами:

<math>D_{ij} = {||X_i - V_j||}, i = 1,...,M; j = 1,...,c </math>

5) Пересчет элементов матрицы разбиения:

при <math>D_{ij} >0</math> : <math>w_{ij} = {{1}\over {{ (\sum_{k=1}^c {{D_{ij}}\over{D_{ik}}} ) }^{2/(m-1)}}}, j = 1,...,c</math>

при <math>D_{ij} =0</math> : <math>w_{ij} = \delta_{ij}, j = 1,...,c</math>, где <math>\delta_{ij}</math> - символ Кронекера

6) Если <math>|| F - F^{*} || < \varepsilon </math>, где <math>F^{*}</math> - матрица нечеткого разбиения предыдущей итерации, то идем далее, иначе возвращаемся на пункт 3.

7) Конец.

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

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

* Поиск <math>V_j</math> - расчет центроидов (пункт 3 алгоритма)
* Нахождение <math>D_{ij}</math> - расстояний между объектами (пункт 4 алгоритма)
* Пересчет <math>w_{ij}</math> - элементов матрицы разбиения (пункт 5 алгоритма)

== Макроструктура алгоритма ==
Основные шаги при реализации алгоритма
* Генерация случайной матрицы размера <math>M</math> на где <math>c</math>, проверка условий
* Расчет центроидов – по сути, скалярное произведение с нормировкой
* Расчет расстояний – в общепринятом случае является скалярным произведением
* Пересчет матрицы – по сути, скалярное произведение
* Проверка условий останова – вычисление нормы

== Схема реализации последовательного алгоритма ==
float ** FuzzyCMeans (float** X, c, m, eps){
n = X.size();
r = X[0].size();
centers = generateZeroFill(c, r)
Wprev = genetateRandFill(n, c);
W = Wprev;
while (true){
// обновляем центры кластеров
for (int i=0; i<c; i++){
float * num = new float []();
float den = 0;
for (int j=0; j<n; j++){
num += pow(W[j][i], m) * X[j];
den+=pow(W[j][i], m);
}
centers[i] = num / den;
}
//обновляем вероятности W и считаем расстояние между матрицами W и Wprev
float max_diff = 0;
for (int i=0; i<n; i++)
for (int j=0; j<c; j++){
total = 0;
for (int m=0; m<с; m++)
total += pow(distance(X[i], centers[j]) / distance(X[i], centers[m]), 2/(m-1));
W[i][j] = 1/total;
max_diff = max(abs(Wprev[i][j]-W[i][j]), max_diff);
Wprev[i][j] = W[i][j];
}
if (max_diff < eps):
break;
}
return W;
}

== Последовательная сложность алгоритма ==
Последовательная сложность алгоритма состоит из сложности каждой итерации умноженной на их количество. Так как число итераций заранее неизвестно и зависит от входных параметров, рассмотрим сложность на каждой итерации. Наибольшую сложность представляет собой пересчет матрицы, сложность которого <math>O(c^2 nd)</math> (по сравнению со сложностью <math>O(cnd)</math> расчета расстояний, вычисления центроидов и проверки условия останова). Итого общая сложность алгоритма <math>O(c^2 ndi)</math>

== Информационный граф ==
Информационный граф представлен на рисунке ниже.

'''Первый ярус''' состоит из <math>M</math> параллельных операций 1, 2, совершаемых в цикле <math>c</math> раз для каждого кластера.

'''Операция 1''': <math>w_{ij}^m</math>, где <math>j</math> - номер итерации в цикле, <math>i</math> - номер параллельной ветви.

'''Операция 2''': <math>w_{ij}^m*X_i</math>

Здесь <math>j</math> - номер итерации в цикле, <math>i</math> - номер параллельной ветви.

На выходе из каждой ветки получаем вектор размера <math>1</math> x <math>c</math> и матрицу размера <math>d</math> x <math>c</math>.
Далее совершаем поэлементное сложение векторов и матриц соответственно, а затем делим каждый столбец в матрице на соответствующий элемент в векторе.

'''Второй ярус''' состоит их <math>M</math> параллельных операций 3, 4, 5 также совершаемых в цикле <math>c</math> раз.

'''Операция 3''': обновление значения <math>w_{ij}</math> по указанной в разделе 1.2 в пункте 5 формуле.

'''Операция 4''': <math>maximum = max(|w_{ij} - w_{ij}^{prev}|, maximum)</math>.

'''Операция 5''': <math>w_{ij}^{prev} = w_{ij}</math>.

Здесь <math>j</math> - номер итерации в цикле, <math>i</math> - номер параллельной ветви.

На выходе из каждой ветки получаем число <math>maximum</math>. Далее находим максимальное значение из полученных величин для каждой ветки. Затем проверяем условие останова алгоритма.

[[File:Scheme3.JPG]]

== Ресурс параллелизма алгоритма ==
Параллельная сложность алгоритма: <math>M*c^2*i</math>. Такая сложность получается за счет распараллеливания на каждом ярусе <math>M</math> операций. Иерархическая структура параллелизма подробно описана в [[#Информационный граф|п.1.7]].

В алгоритме не возникает скошенного параллелизма.

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

* Входные данные алгоритма: набор векторов <math>x_i</math> размерности <math>d</math>, где <math>i = 1,...,M</math>; <math>M</math> - количество векторов.
* Объем входных данных: <math>M*d</math> , [количество наблюдений * размерность].
* Выходные данные алгоритма: матрица вероятностей принадлежности векторов кластерам <math>M</math> на <math>c</math>.
* Объем выходных данных: <math>M*c</math> , [количество наблюдений * количество кластеров].

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

* Соотношение последовательной и параллельной формы алгоритма: <math>M</math>
* Вычислительная мощность: <math>{dc^2i} \over {c+d}</math>.
* Устойчивость: алгоритм не является устойчивым, поэтому существует много исследований о том, как первоначально выбрать параметры кластеризации.
* Сбалансированность: в данном алгоритме операция умножения доминирует над операцией сложения. Операции между параллельными ветвями сбалансированны.
* Детерминированность: алгоритм не является детерминированным, так как матрица нечеткого разбиение генерируется произвольно.
* Степень исхода вершины информационного графа ( для одной интерации): 2 (3 - с учетом, если выходные данные пошли на следующую итерацию).

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

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

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

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

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

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

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

* число процессоров [1 : 128];
* размер матрицы [10000 : 80000].

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

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

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

[[file: FuzzyCMeansPerformance.png |thumb|center|700px|Рисунок 1. Параллельная реализация нечеткого алгоритма С-средних. Изменение производительности в зависимости от числа процессоров и размера матрицы.]]
[[file: FuzzyCMeansEfficiency2.png|thumb|center|700px|Рисунок 2. Параллельная реализация нечеткого алгоритма С-средних. Изменение эффективности в зависимости от числа процессоров и размера матрицы.]]

Построим оценки масштабируемости выбранной реализации нечеткого алгоритма С-средних:
* По числу процессов: 0.007. При увеличении числа процессов эффективность на рассмотренной области изменений параметров запуска увеличивается.
* По размеру задачи: -0.0016. При увеличении размера задачи эффективность уменьшается.
* По двум направлениям: 0,000077. При рассмотрении увеличения как вычислительной сложности, так и числа процессов на всей рассмотренной области значений эффективность увеличивается, однако скорость увеличения эффективности небольшая.

Была использована следующая реализация алгоритма.

#include <mpi.h>
#include <stdio.h>
#include <iostream>
#include <stdlib.h>
#include <math.h>
#include <string.h>
#include <time.h>
using namespace std;
double **x; //input matrix of size (n x x_dim)
int n;
int x_dim;
double **centroids; //cluster centroids matrix of size (n_cluster x x_dim)
int n_cluster; // number of clusters
double **w; //probability matrix of size (n x n_cluster)
double **dist; //distances matrix of size (n x n_cluster)
double eps; //max error
double m; //parameter of algo
int max_iter; // max num of iterations
double **num;
double *den;
double *allden;
double *err;
double *total_err;
int rank, size;
double ** generateZerosMatrix(int r, int c){
double ** arr = new double* [r];
for (int i = 0; i < r; ++i){
arr[i] = new double[c]();
}
return arr;
}
int generate_data()
{
//generate matrix
x = generateZerosMatrix(n, x_dim);
centroids = generateZerosMatrix(n_cluster, x_dim);
w = generateZerosMatrix(n, n_cluster);
dist = generateZerosMatrix(n, n_cluster);
num = generateZerosMatrix(n_cluster, x_dim);
//generate vectors
den = new double [n_cluster]();
allden = new double [n_cluster]();
//for stopping algorithm
err = new double;
total_err = new double;
srand(time(0));
//initialize w randomly with restrictions
for (int i = 0; i < n; ++i){
double sum = 0;
for (int j = 0; j < n_cluster; ++j){
w[i][j] = rand();
sum += w[i][j];
}
for (int j = 0; j < n_cluster; ++j){
w[i][j] /= sum;
}
}
//initialize x randomly
for (int i = 0; i < n; ++i)
for (int j = 0; j < x_dim; ++j)
x[i][j] = rand();
return 0;
}
double make_iteration() {
// calculate centroids centers
for (int i = rank; i < n; i+=size)
for (int j = 0; j < n_cluster; ++j){
double mu = pow(w[i][j], m);
den[j] += mu;
for (int k = 0; k < x_dim; ++k)
num[j][k] = mu * x[i][k];
}
MPI_Allreduce(den, allden, n_cluster, MPI_DOUBLE, MPI_SUM, MPI_COMM_WORLD);
for (int j=0; j < n_cluster; ++j)
MPI_Allreduce(num[j], centroids[j], x_dim, MPI_DOUBLE, MPI_SUM, MPI_COMM_WORLD);
for (int i = 0; i < n_cluster; ++i)
for (int j = 0; j < x_dim; ++j)
centroids[i][j] /= allden[i];
// calculate distances and probabilities, check stop conditions
double err = 0.0;
for (int i = rank; i < n; i+=size)
for (int j = 0; j < n_cluster; ++j){
for (int k = 0; k < x_dim; ++k)
dist[i][j] += (x[i][k] - centroids[j][k]) * (x[i][k] - centroids[j][k]);
double w_prev = w[i][j];
for (int k = 0; k < n_cluster; ++k)
w[i][j] += dist[i][j] / dist[i][k];
w[i][j] = 1.0 / pow(w[i][j], 1.0 / (m - 1));
err = fmax(err, abs(w_prev - w[i][j]));
}
return err;
}
int FCM(){
*total_err = eps+1;
int cur_iter = 0;
while (cur_iter < max_iter && *total_err > eps){
*err = make_iteration();
MPI_Allreduce(err, total_err, 1, MPI_DOUBLE, MPI_MAX, MPI_COMM_WORLD);
cur_iter++;
}
return cur_iter;
}
void clearMatrix(double ** matr, int r, int c){
for (int i = 0; i < r; ++i){
delete [] matr[i];
}
delete [] matr;
}
int memory_free(){
clearMatrix(x, n, x_dim);
clearMatrix(centroids, n_cluster, x_dim);
clearMatrix(w, n_cluster, n);
clearMatrix(num, n_cluster, x_dim);
clearMatrix(dist, n, n_cluster);
delete [] den;
delete [] allden;
delete err;
delete total_err;
return 0;
}
int main(int argc, char **argv){
MPI_Init(&argc, &argv);
MPI_Comm_size(MPI_COMM_WORLD, &size);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
int n_repeat = strtol(argv[1], NULL, 10);
int nx_min = strtol(argv[2], NULL, 10);
int nx_max = strtol(argv[3], NULL, 10);
int step = strtol(argv[4], NULL, 10);
x_dim = strtol(argv[5], NULL, 10);
m = strtod(argv[6], NULL);
n_cluster = strtol(argv[7], NULL, 10);
max_iter = strtol(argv[8], NULL, 10);
eps = strtod(argv[9], NULL);
//for all input matrix sizes
for (n = nx_min; n <= nx_max; n += step){
double start, finish, time_elapsed_iter=0;
int total_iterations = 0;
//repeat for getting mean value
for (int i = 0; i < n_repeat; ++i) {
generate_data();
MPI_Barrier(MPI_COMM_WORLD);
start = MPI_Wtime();
total_iterations += FCM();
finish = MPI_Wtime();
memory_free();
time_elapsed_iter += (finish-start);
}
time_elapsed_iter /= total_iterations;
if (rank == 0) {
cout << n << " " << size << " " << time_elapsed_iter << endl;
}
}
MPI_Finalize();
}

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

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

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

* Реализация алгоритма на POSTGRESQL: http://num-meth.srcc.msu.ru/zhurnal/tom_2012/pdf/v13r207.pdf
* Библиотека для MATLAB: http://www.mathworks.com/help/fuzzy/fcm.html (распространяется на коммерческой основе)

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

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

2016-11-17T07:29:12Z

Coctic:

= Статья [[Нечеткий алгоритм C средних]] =
* Не указан вклад каждого автора [[Участник:Coctic|Coctic]] ([[Обсуждение участника:Coctic|обсуждение]]) 12:54, 25 октября 2016 (MSK)
** Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 10:55, 1 ноября 2016 (MSK)
* п. 1.2 номера формул следует выравнивать по правому краю, а не прилеплять вплотную к формуле [[Участник:Coctic|Coctic]] ([[Обсуждение участника:Coctic|обсуждение]]) 12:54, 25 октября 2016 (MSK)
** Условно исправлено. Форматирование сделано негодными средствами, но неясно, установлены ли средства (https://en.wikipedia.org/wiki/Help:Displaying_a_formula#Equation_numbering), чтобы сделать правильно [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 10:55, 1 ноября 2016 (MSK)
*** Пробовал сделать указанными Вами средствами - на этом ресурсе указанные Вами шаблоны не заработали [[Участник:Yushin|Павел Юшин]]
* п. 1.3 состоит из одного предложения и не дает достаточно информации [[Участник:Coctic|Coctic]] ([[Обсуждение участника:Coctic|обсуждение]]) 12:54, 25 октября 2016 (MSK)
** Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 10:55, 1 ноября 2016 (MSK)
* п. 1.7 приведенный рисунок не является информационным графом: не все дуги ориентированы, имеются циклы [[Участник:Coctic|Coctic]] ([[Обсуждение участника:Coctic|обсуждение]]) 12:54, 25 октября 2016 (MSK)
** Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 10:55, 1 ноября 2016 (MSK)
* п. 1.9 не приведено оценки объема входных и выходных данных [[Участник:Coctic|Coctic]] ([[Обсуждение участника:Coctic|обсуждение]]) 12:54, 25 октября 2016 (MSK)
** Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 10:55, 1 ноября 2016 (MSK)
* в разделе 2 отсутствуют необходимые пункты, п. 2.2 должен быть 2.7 [[Участник:Coctic|Coctic]] ([[Обсуждение участника:Coctic|обсуждение]]) 12:54, 25 октября 2016 (MSK)
** Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 10:55, 1 ноября 2016 (MSK)
* В списке литературы 1 ссылка - скопированный шаблон без реальной ссылки, 2 ссылка - просто URL без выходных данных источника [[Участник:Coctic|Coctic]] ([[Обсуждение участника:Coctic|обсуждение]]) 12:54, 25 октября 2016 (MSK)
** Исправлено частично. Ссылка 2 по-прежнему не имеет достаточных выходных данных [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 10:55, 1 ноября 2016 (MSK)
*** На сайте, где студентам выдавалось задание ( http://parallel.ru/ss16 ), данный материал предоставлялся в списке источников (номер [8]) в таком же виде, как он указан в данной статье [[Участник:Yushin|Павел Юшин]]
**** Не вижу никакого противоречия с тем, что я написал в замечании [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 10:47, 7 ноября 2016 (MSK)
**** Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 16:34, 13 ноября 2016 (MSK)

----
* п. 2.4. Приведен график зависимости эффективности от параметров задачи. Не указано, о какой конкретно эффективности идет речь. [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 10:29, 17 ноября 2016 (MSK)

Участник:Nikmedoed/Нечеткий алгоритм С-средних (Fuzzy C-means)

2016-11-17T07:27:24Z

Coctic:

{{algorithm
| name = Нечеткий алгоритм С-средних (Fuzzy C-means)
| serial_complexity = <math>O(c^2 MI + cMnI), (I</math> - число итераций, <math>c</math> - количество кластеров, <math>M</math> - число точек, <math>n</math> - размерность точек (свойств на объект)<math>)</math>
| input_data = <math>Mn</math>
| output_data = <math>cM</math>
| pf_height = <math> O(c^2 I + cnI)</math>
| pf_width = <math>O( M )</math>
}}

Авторы: [[Участник:Nikmedoed|Н.А. Муромцев]] - перенос в вики, раздел 2, картинки, [[Участник:illusive_mike|М.С. Дворецкий]] - раздел 1

'''Нечеткий алгоритм С-средних''' (''Fuzzy C-means'') - позволяет получить нечёткую кластеризацию больших наборов числовых данных, что позволяет корректно определять объекты на границах кластеров. Однако, выполнение данного алгоритма требует серьёзных вычислительных ресурсов, а также изначального задания количества кластеров. Кроме того, может возникнуть неоднозначность с объектами, удалёнными от центров всех кластеров.

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

== Общее описание алгоритма ==
Алгоритм кластеризации Fuzzy C-Means (FCM) был предложен Дж. Данном в 1973 году <ref>Dunn, J.C.: A Fuzzy Relative of the ISODATA Process and Its Use in Detecting Compact Well-Separated Clusters. Journal of Cybernetics. 3 (1973): 32–57</ref> и доработан Дж. Бездеком в 1981 году <ref>Bezdek, J.C.: Pattern Recognition with Fuzzy Objective Function Algorithms. Plenum Press, New York (1981). ISBN 0-306-40671-3</ref>. В отличие от большинства существующих алгоритмов кластеризации, данный алгоритм является нечётким – каждый из объектов не входит однозначно в какой-либо кластер, а принадлежит всем кластерам с различными степенями принадлежности. Это даёт преимущества в качестве разбиения в случаях, когда кластеры находятся близко друг к другу, и большое число точек находится на их границах. Однако ценой такой нечёткости служат большие вычислительные затраты, чем у таких чётких алгоритмов, как [[Hard C-Means]] и [[K-Means]], при сохранении таких их недостатков, как априорное определение числа кластеров и отсутствие гарантии глобальной оптимальности результата.

== Математическое описание алгоритма ==
Исходные данные: массив объектов <math>{X_k}\in{\R^n}, k=\overline{1,M}</math>, число кластеров c, экспоненциальный вес <math>m\in{[1,\infty)}</math>, параметр останова <math>\varepsilon>0</math>.

Вычисляемые данные: матрица разбиения <math>F</math> размера <math>M\times c</math> (элементы <math>\mu_{ki}\in[0,1]</math>, <math>\sum^{c}_{i=1} {\mu_{ki}} = 1</math>), центры кластеров <math>V_i</math>, расстояния <math>D_{ki}</math> между объектами и центрами кластеров.

'''Формулы метода (вычисляются последовательно на каждой итерации):'''

1. Уточнение центров кластеров по степеням принадлежности
:<math>
\begin{align}
&V_i=\frac{\sum^{M}_{k=1} {\mu^m_{ki} * X_k}}{\sum^{M}_{k=1} {\mu^m_{ki}}},i=\overline{1,c}
\end{align}
</math>
2. Расчёт расстояний между новыми центрами кластеров и точками данных
:<math>
\begin{align}
&D_{ki}=\sqrt{{\lVert X_k - V_i \rVert}^2},k=\overline{1,M},i=\overline{1,c}
\end{align}
</math>
3. Пересчёт степеней принадлежности объектов кластерам
:<math>
\begin{align}
&\mu_{ki}=\frac{1}{{ \sum^{c}_{j=1} \left ( {\frac{D_{ki}}{D_{kj}}} \right ) }^{{2}/{m-1}}
},k=\overline{1,M},i=\overline{1,c}\\
\end{align}
</math>

На каждой итерации алгоритма происходит уточнение элементов матрицы <math>F</math>. Выходом алгоритма служит матрица <math>F</math>, к которой алгоритм сходится. Факт того, что алгоритм сошёлся, устанавливается проверкой вида <math>\max_{k = \overline{1,M},i = \overline{1,c}} {( \left | \mu_{ki} - \mu_{ki}^* \right |)} < \varepsilon</math> либо <math>\max_{i = \overline{1,c}} {( \left | V_i - V_i^* \right |)} < \varepsilon</math>, где <math>\mu_{ki}^* (V_i^*)</math> – значение <math>\mu_{ki}(V_i)</math>, вычисленное на предыдущей итерации.

== Вычислительное ядро алгоритма ==
Вычислительное ядро алгоритма Fuzzy C-Means составляют шаги вычисления центров кластеров, расстояний между ними и точками данных и в особенности пересчёта матрицы степеней принадлежности точек данных.

При реальном вычислении некоторые повторяющиеся вычисления могут быть устранены. Так, для шага вычисления центров кластеров величины <math>\mu_{ki}^m</math> могут вычисляться однократно и умножаться на <math>X_k</math> при включении в сумму, записанную в числителе. Для шага вычисления расстояний между центрами кластеров и точками, операция взятия квадратного корня не является обязательной, так как в дальнейшем на шаге вычисления степеней принадлежности можно непосредственно использовать квадраты этих расстояний, и сумма в знаменателе будет приобретать вид:

<math>\sum^{c}_{j=1} {\left ( \frac{D_{ki} ^ {2}}{D_{kj} ^ {2}} \right )}^{{1}/{m-1}}</math>

== Макроструктура алгоритма ==
Алгоритм включает в себя три основных этапа – вычисление центров кластеров, вычисление расстояний между центрами кластеров и точками данных (включающее в себя макрооперации вычитания векторов и вычисления их норм, как правило в Евклидовом пространстве) и пересчёт матрицы принадлежности.

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

Инициализация происходит случайным заполнением матрицы принадлежности <math>F</math> с соблюдением условия нормировки <math>\sum_{i=1}^c {\mu_{ki} =1}</math> и переходом к шагу 1, либо случайным определением центров кластеров <math>V_i</math> и переходом к шагу 2.

Далее осуществляются итерации следующего вида:

# <math>V_i=\frac{\sum_{k=1}^{M} {\mu_{ki}^m * X_k}}{\sum_{k=1}^{M} {\mu_{ki}^m} },i=\overline{1,c}</math>
# <math>D_{ki}=\sqrt{{\lVert X_k - V_i \rVert}^2},k=\overline{1,M},i=\overline{1,c}</math>
# <math>\mu_{ki}=\frac{1}{{ \sum^{c}_{j=1} {\left ( \frac{D_{ki}}{D_{kj}} \right )} }^{{2}/{m-1}}
},k=\overline{1,M},i=\overline{1,c}</math>

В конце каждой итерации проверяется условие останова вида <math>\max_{k = \overline{1,M},i = \overline{1,c}} {( \left | \mu_{ki} - \mu_{ki}^* \right |)} < \varepsilon</math>, либо <math>\max_{i = \overline{1,c}} {( \left | V_i - V_i^* \right |)} < \varepsilon</math>, где <math>\mu_{ki}^* (V_i^*)</math> – значение <math>\mu_{ki}(V_i)</math>, вычисленное на предыдущей итерации. Если условие не выполнено, осуществляется переход к шагу 1.

== Последовательная сложность алгоритма ==
При кластеризации <math>M</math> объектов данных, представленных точками в <math>\R^n</math>, на <math>c</math> кластеров, алгоритм Fuzzy C-Means в последовательном варианте имеет вычислительную сложность – <math>O(c^2 MI+cMnI)</math>, где <math>I</math> – число итераций. Если считать размерность данных <math>n</math> малой, то эта сложность сводится к <math>O(c^2 MI)</math>. Основной частью алгоритма в этом случае является пересчёт матрицы принадлежностей, требующий вычисления <math>cM</math> сумм из <math>c</math> слагаемых на каждой итерации.

== Информационный граф ==
Приведём граф единичной итерации алгоритма в параллельном оптимизированном варианте (метод распараллеливания взят в <ref>Kwok, T., Smith, K.,
Lozano, S., Taniar, D.: [http://num-meth.srcc.msu.ru/zhurnal/tom_2012/pdf/v13r207.pdf Parallel Fuzzy c-Means Clustering for Large Data Sets], последнее обращение 25.10.2016</ref>):

[[File:C-means_paralle_graph.png|thumb|upright=2.5|frame|center|alt=Paralel Fuzzy C-Means|Каждая вершина данного графа соответствует операциям из алгоритма, указанным при помощи указанных формул. Каждый из p столбцов соответствует работе одного из процессов. Пометки справа указывают число повторений каждого узла в ходе одной итерации.]]

Раздел 1.8 уточняет, соответствуют ли эти повторения однотипным ярусам или точкам данных, вычисления для которых можно распараллелить и далее.

Каждый процесс обладает следующими данными:
* координатами точек данных <math>X_k</math>, <math>k=\overline{1+rnk* \frac{M}{p},rnk*(\frac{M}{p}+1)}</math>, где <math>rnk</math> – номер процесса,
* значениями <math>\mu_{ki}</math> степени принадлежности для своих точек (<math>k=\overline{1+rnk* \frac{M}{p},rnk*(\frac{M}{p} +1)}, i=\overline{1,c}</math>),
* координатами центров кластеров <math>V_i</math>, <math>i=\overline{1,c}</math>.
Суммы <math>\sum_{k=1+rnk*\frac{M}{p}}^{rnk * ( \frac{M}{p} +1 )} {\mu_{ki}^m}</math> и <math>\sum_{k=1+rnk*\frac{M}{p}}^{rnk * ( \frac{M}{p} +1 )} {\mu_{ki}^m X_k}</math> вычисляются одновременно, поэтому значения <math>\mu_{ki}^m</math> вычисляются по одному разу за итерацию. Таким образом, второй ярус операций на рисунке на деле не содержит операций возведения в степень.
За счёт линейности большинства выражений относительно данных по точкам, процессы взаимодействуют только при редукции сумм, составляющих <math>V_i</math>. Всё остальное время каждый процессор работает только со своими <math>\frac{M}{p}</math> точками. Это обеспечивает применимость алгоритма для больших <math>M</math>.

== Ресурс параллелизма алгоритма ==
При распараллеливании по точкам исходных данных и условии останову по малому изменению степеней принадлежности выполнение одной итерации алгоритма FCM может быть разделено на следующие ярусы:
* <math>c</math> ярусов нахождения частичных сумм знаменателя (по <math>\frac{M}{p}-1</math> сложений, <math>\frac{M}{p}</math> операций возведения в степень на процесс),
* <math>c</math> ярусов нахождения частичных сумм числителя (по <math>\frac{M}{p} -1</math> сложений, <math>\frac{M}{p}</math> умножений на процесс),
* <math>2</math> редукции сумм и передач значений <math>V_i</math> процессам (получение <math>c(n+1)</math> значений, <math>cn</math> делений),
* <math>c</math> ярусов вычисления расстояний до центров (по <math>n-1</math> сложений, <math>n</math> вычитаний, <math>n</math> умножений), каждый процесс получает <math>\frac{M}{p}</math> точек на обработку,
* <math>c</math> ярусов вычисления степеней принадлежности точек (по <math>c+1</math> делений, c возведений в степень, <math>c-1</math> сложений), каждый процесс получает <math>\frac{M}{p}</math> точек на обработку,
* до <math>c</math> ярусов проверки условий останова (по <math>1</math> вычитанию, <math>1</math> сравнению), каждый процесс получает <math>\frac{M}{p}</math> точек на обработку,
* <math>1</math> редукция для обмена статусом завершения.
Таким образом, при распараллеливании по точкам исходных данных при условии наличия в каждом узле достаточного объёма памяти для хранения всего массива координат центров кластеров высота и ширина ЯПФ алгоритма FCM равны соответственно <math>O(c^2 I+cnI)</math> и <math>O(M)</math>.

== Входные и выходные данные алгоритма ==
'''Входные данные''': массив векторов <math>X_i</math>, число кластеров <math>c</math>, экспоненциальный вес <math>m\in{[1,\infty)}</math>, параметр останова <math>\varepsilon>0</math>.

'''Объём входных данных''': <math>Mn</math> для входных векторов, 3 вспомогательных параметра.

'''Выходные данные''': матрица принадлежности <math>F</math> (элементы <math>\mu_{ki}\in[0,1]</math>). Условие нормировки: <math>\sum^{c}_{i=1} {\mu_{ki}} = 1</math>.

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

== Свойства алгоритма ==
В случае неограниченного распараллеливания по точкам данных (1 процесс на точку), отношение последовательной сложности алгоритма к параллельной пропорционально <math>M</math>.

Параметр <math>m</math> задаёт степень «размытости» кластеров. В отсутствие априорных данных его обычно берут равным 2. В предельном случае сведения параметра <math>m</math> к значению 1, кластеры становятся чёткими и алгоритм вырождается в алгоритм кластеризации K-Means.

Алгоритм недетерминирован, начальное положение кластеров задаётся случайно либо явно, либо опосредованно (через матрицу принадлежности). Алгоритм сходится к локальному экстремуму <ref>Höppner, F., Klawonn, F.: [https://public.fh wolfenbuettel.de/~klawonn/Papers/hoeppnerklawonntfs03.pdf A Contribution to Convergence Theory of Fuzzy c-Means and Derivatives], Дата последнего обращения: 13.10.2016</ref> и, таким образом, не гарантирует оптимальный результат при случайном выборе начальных значений.

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

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

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

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

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

[[File:График.png|thumb|upright=2.5|frame|right|alt=Paralel Fuzzy C-Means time to iteration|График зависимости времени выполнения итерации параллельного нечеткого алгоритма С-средних (Fuzzy C-means) от количества процессоров и количества кластеризуемых вершин]]

[[File:Effect_parallel_fuzzy_c-means.png|thumb|upright=2.5|frame|right|alt=Paralel Fuzzy C-Means efficiency|График эффективности параллельного нечеткого алгоритма С-средних (Fuzzy C-means) в зависимости от количества процессоров и количества кластеризуемых вершин.]]

Исследование проведено на суперкомпьютере IBM Blue Gene/P<ref>[http://hpc.cs.msu.ru/bgp Описание вычислительного комплекса IBM Blue Gene/P]</ref>.
Для исследования была использована последовательная реализация алгоритма и реализован её [https://github.com/nikmedoed/Parallel-Fuzzy-C-means параллельный вариант]<ref>[https://github.com/nikmedoed/Parallel-Fuzzy-C-means Параллельная реализация алгоритма Fuzzy C-Means]</ref>.

Для упрощения экспериментов было решено использовать количество вершин для кластеризации и количество процессов равное степени двойки, поэтому для каждого эксперимента были выбраны значения:
* <math>2^v, v=\overline{0,9}</math>, для количества процессоров;
* <math>2^w, w=\overline{10,20}</math>, для количества кластеризуемых вершин.

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

Полученные результаты говорят о хорошей масштабируемости реализации алгоритма. Для большинства экспериментов эффективность находится в пределах 100±3%. Спад эффективности при малом числе вершин и большом числе процессоров обуславливается тем, что с уменьшением числа вершин, обрабатываемых каждым процессором, растёт доля времени обмена данных между процессорами, не зависящего от числа вершин.

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

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

== Существующие реализации алгоритма ==
* пакет MATLAB <ref>[http://www.mathworks.com/help/fuzzy/fcm.html Документация пакета MATLAB, функция fcm], последнее обращение 15.10.2016</ref>
* Реализация алгоритма на POSTGRESQL <ref>[http://num-meth.srcc.msu.ru/zhurnal/tom_2012/pdf/v13r207.pdf Реализация алгоритма Fuzzy C-means на POSTGRESQL], последнее обращение 15.10.2016</ref>

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

[[en:Parallel Fuzzy c-Means Clustering]]

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

2016-11-17T07:27:11Z

Coctic: /* Статья Участник:Nikmedoed/Нечеткий алгоритм С-средних (Fuzzy C-means) */

Участник:Demon smd/Нечеткий алгоритм С средних

2016-11-16T15:28:41Z

Coctic:

{{algorithm
| name = Нечеткий алгоритм C средних (Fuzzy C-means)
| serial_complexity = <math>O(C^2*N*D*IterNumber)</math>
| pf_height = <math>O(\log_{2}C^4*|X|^3) * IterNumber</math>
| pf_width = <math>O(C^2*|X|)</math>
| input_data = <math>|X|*p</math>, где <math>p</math> - размерность входных векторов
| output_data = <math>|X|*C </math>
}}

Авторы описания алгоритма:
[[Участник:Demon smd|Д.А.Гуськов]]
[[Участник:marina abramenkova|М.А.Абраменкова]]
Во все разделы вклад равноценный.

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

=== Общее описание алгоритма ===
Нечёткий алгоритм кластеризации С-средних был разработан (для случая m=2) J.C. Dunn в 1973 г.
<ref>Dunn, J. C. (1973-01-01). "A Fuzzy Relative of the ISODATA Process and Its Use in Detecting Compact Well-Separated Clusters". Journal of Cybernetics. 3 (3): 32–57. doi:10.1080/01969727308546046. ISSN 0022-0280.</ref>
и усовершенствован (для случая m>1)
J.C. Bezdek в 1981 г. <ref>Bezdek, James C. (1981). Pattern Recognition with Fuzzy Objective Function Algorithms. ISBN 0-306-40671-3.</ref>
. В отличие от алгоритма c-means данный метод кластеризации предполагает, что входные данные могут принадлежать более, чем одному кластеру одновременно.
Алгоритм получает на вход набор кластеризуемых векторов, количество кластеров, коэффициент неопределённости m и коэффициент <math>\varepsilon > 0</math>, определяющий точность алгоритма. На выходе алгоритма получаем матрицу вероятностей принадлежности каждого входного вектора каждому кластеру.

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

1) расчёт центров кластеров

2) расчёт Евклидова расстояния от каждого вектора до центра каждого кластера

3) расчёт и нормализация коэффициентов принадлежности векторов кластерам

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

=== Математическое описание алгоритма ===
Нечеткий алгоритм С средних минимизирует величину:
:<math>
\begin{align}
J_{m} = \sum_{i = 1}^{N}\sum_{j = 1}^{C}u_{i,j}^m\left\Vert{x_{i}-c_{j}}\right\|^2 & , & & 1 \le m \le \infty , \\
\end{align}
</math>
где m - это действительное число не меньше единицы, <math>u_{i,j}</math> - коэффициент принадлежности вектора <math>x_{i}</math> к кластеру <math>c_{j}</math>, <math>x_{i}</math> - <math>i</math>-ый компонент <math>N</math>-мерного вектора <math>x</math>, <math>c_{j}</math>
- центр <math>j</math>-ого кластера, а <math>\left\Vert{*}\right\|</math> - это любая норма, определяющая расстояние от вектора до центра кластера.
Нечёткое разбиение входных данных на кластеры производится итеративной оптимизацией вышеуказанной функции с обновлением коэффициента принадлежности <math>u_{i,j}</math> и переопределением центра кластера <math>c_{j}</math> на каждой итерации алгоритма.

==== Вычисляемые данные на каждой итерации ====
* Центры кластеров рассчитываются по следующей формуле: <math>c_{j} = {{\sum_{i = 1}^{n}{u_{i,j}^m} * x_{i}} \over {\sum_{i = 1}^{n}{u_{i,j}^m}}}</math>, где <math>u_{i,j}</math> — коэффициент принадлежности <math>x_{i}</math> вектора к кластеру <math>c_{j}</math>.

* Коэффициент принадлежности рассчитывается по формуле: <math>u_{i,j} = {1 \over \sum_{k = 1}^{C}{({\left\Vert{x_{i}-c_{j}}\right\| \over \left\Vert{x_{i}-c_{k}}\right\|})}^{2 \over m-1}}</math>

* Решающая функция рассчитывается по формуле: <math>\max_{i,j}(|u_{i,j}^{(k)} - u_{i,j}^{(k-1)}|)</math>, где <math>k</math> - номер итерации алгоритма

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

Ядром алгоритма является:
* вычисление новых центров кластеров
* для каждого входного вектора вычисление Евклидова расстояния до центров кластеров, а также коэффициента принадлежности кластерам
* вычисление решающей функции

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

В каждой итерации алгоритма происходит 3 основных действия описанных в п. 1.2.1:
*вычисление центров кластеров
*вычисление коэффициентов принадлежности
*вычисление решающей функции
Подробное описание макроструктур в виде кода приведено в пункте 1.5

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

Схему реализации последовательного алгоритма можно описать на C++ следующим образом:

<source lang="C++">

FCM (X[], C, m, eps){
float deside = 0;
float newDeside = 0;
generateMembershipDegree(); //заполняет uPrev[][] случайными нормрованными коэффициентами
while (true){
newDeside = deside;

//вычисление центров кластеров
for (int j=0; j<C; j++){ //для каждого кластера
float numerator = 0;
float denumerator = 0;
for (int i=0; i<X.size(); i++){ //для каждого вектора
numerator+=pow(u[i][j], m) * x[i];
denumerator+=pow(u[i][j], m);
}
c[j] = numerator / denumerator;
}

//вычисление коэффициентов u[][]
for (int i=0; i<X.size(); i++) //для каждого вектора
for (int j=0; j<C; j++){ //для каждого кластера
sum = 0;
for (int k=0; k<C; k++)
sum+= pow( dist(x[i], c[j]) / dist(x[i], c[k]), 2/(m-1));
u[i][j] = 1/sum
}

//определения максимального различия между u[][] и uPrev[][]
float max = 0;
for (int i=0; i<X.size(); i++) //для каждого вектора
for (int j=0; j<C; j++){ //для каждого кластера
if (abs(uPrev[i][j]-u[i][j])>max)
max = abs(uPrev[i][j]-u[i][j]);

if (eps <= max)
for (int i=0; i<X.size(); i++) //для каждого вектора
for (int j=0; j<C; j++){ //для каждого кластера
uPrev[i][j]=u[i][j];
else
break;

}
return u;
}
</source>

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

Последовательная сложность всего алгоритма складывается из сложности операций на каждой итерации умноженную на количество итераций. Так как в данном алгоритме количество итераций не является фиксированным и зависит от:
* параметра <math>\varepsilon</math>
* набора входных векторов <math>x</math>
* выбора начальных коэффициентов <math>u</math>
то в данном пункте будет приведена сложность одной итерации относительно количества входных векторов.
Как видно из предыдущего пункта, для вычисления центров кластеров требуется <math>O(2*C*|X|)</math> операций, для определения коэффициентов <math>u</math> - <math>O(C^2*|X|)</math> операций, а для вычисления решающей функции - <math>O(2*C*|X|)</math> операций, где <math>|X|</math> - число входных векторов, а <math>C</math> - количество кластеров.

Таким образом итоговая сложность одной итерации составляет <math>O(C^2*|X|)</math>.

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

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

[[File:FCMIG.png|thumb|center|1200px|Рисунок 1. Информационный граф алгоритма. (1)-(7) - это наборы последовательных действий (например, (2) - последовательные операции деления, взятия адреса и присваивания).]]

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

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

Сложность алгоритма будем рассчитывать в предположении, что число вычислительных ядер стремится к бесконечности. Как видно из информационного графа, параллельная сложность вычисления центров кластеров составляет <math>O(\log_{2} C*|X|)</math>, вычисления коэффициентов принадлежности - <math>O(\log_{2} C^2*|X|)</math>, а вычисления решающей функции - не больше чем <math>O(\log_{2} C*|X|)</math>.

Таким образом параллельная сложность итерации алгоритма составляет <math>O(\log_{2} C^4*|X|^3)</math>.

Так как задачи, решаемые в макроструктуре алгоритма могут быть сведены к задачам вычисления суммы элементов массива и максимального элемента массива, то на <math>i</math>-ом ярусе графа будет находиться <math>{N}\over{2^i}</math> операции, где N - количество элементов массива.

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

==== Входные данные алгоритма ====
* <math>X</math> - набор из <math>|X|</math> входных векторов длины <math>p</math>
* <math>C</math> - количество кластеров
* <math>m</math> - коэффициент неопределённости
* <math>\varepsilon > 0</math> - коэффициент, определяющий точность алгоритма.

Объем входных данных: <math>|X|*p+3</math>

==== Выходные данные алгоритма ====
* <math>u</math> - матрица принадлежности векторов кластерам

Объем выходных данных: <math>|X|*C</math>

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

Увеличение скорости работы алгоритма при распараллеливании на бесконечном количестве процессоров составляет <math>O({{C^2*|X|}\over{\log_{2} (C^4*|X|^3)}})</math>. Например, для разбиения 1000 элементов на 10 кластеров производительность параллельного алгоритма будет в 2315 раз больше, а на 20 кластеров - уже в 8477 раз.

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

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

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

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

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

Как видно из предыдущих пунктов, масштабируется данный алгоритм хорошо. С увеличением количества процессоров время работы падает, а с увеличением количества входных данных и количества кластеров - растёт. На рисунках показана масштабируемость алгоритма.
[[File:FCMCOMP1.jpg|thumb|center|1500px|Рисунок 2. Масштабируемость алгоритма. Зависимость сложности алгоритма от количества процессоров и входных данных при фиксированном количестве кластеров.]]
[[File:FCMCOMP2.jpg|thumb|center|1500px|Рисунок 3. Масштабируемость алгоритма. Зависимость сложности алгоритма от количества процессоров и кластеров при фиксированном количестве входных данных.]]

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

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

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

Существует множество реализаций данного алгоритма. Рассмотрим некоторые из них:

- Например, тут: https://habrahabr.ru/post/208496/
<ref>Нестер А. "Алгоритм нечёткой кластеризации fuzzy c-means на PHP". [html](https://habrahabr.ru/post/208496/)</ref>
приведено краткое описание алгоритма и приведена его реализация на php. В данной статье довольно подробно расписан каждый шаг алгоритма и приведён соответствующий ему фрагмент кода.

- Тут: http://num-meth.srcc.msu.ru/zhurnal/tom_2012/v13r207.html
<ref>Миниахметов Р.М., Цымблер М.Л. "Интеграция алгоритма кластеризации Fuzzy c-Means в PostgreSQL". [html](http://num-meth.srcc.msu.ru/zhurnal/tom_2012/v13r207.html)</ref>
приводится реализация алгоритма для PostgreSQL, а также прилагается скрипт внедрения алгоритма.

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

<references \>

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

2016-11-16T15:28:29Z

Coctic:

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

2016-11-16T13:55:33Z

Coctic:

Участник:Ян-Мартин Тамм/Строгий алгоритм С средних

2016-11-16T13:55:13Z

Coctic:

{{algorithm
| name = Строгий алгоритм С средних (K-means, Hard C-Means)
| serial_complexity = <math>O(nkdi)</math>
| pf_height = <math>O(log_2(k)log_2(d)i)</math>
| pf_width = <math>O(nkd)</math>
| input_data = <math>nd+1</math>
| output_data = <math>nk</math>
}}
Автор: [[Участник:Darel|Ян-Мартин Тамм]]

= Свойства и структура алгоритма =
== Общее описание алгоритма ==
Строгий алгоритм C средних, более известный как K-средних, решает задачу разделения векторов в многомерном пространстве на заданное количество кластеров. При этом каждый вектор принадлежит только одному кластеру, поэтому алгоритм называется строгим, в то время как нечеткий алгоритм C средних (Fuzzy C-means, Soft K-means) определяет степень принадлежности вектора каждому из кластеров.
 
Данная задача является NP-трудной, тем не менее описываемый алгоритм сходится к локальному оптимуму. Глобальный оптимум не гарантируется и зависит от первоначального распределения центров кластеров и их количества. Общая идея алгоритма такова: фиксируем число кластеров <math>k</math>, произвольным образом выбираем центры кластеров, после чего повторяем следующие два действия, пока не будет выполнено условие остановки:
#Распределяем каждый вектор в ближайший кластер
#Пересчитываем значения центров как среднее значение координат векторов в каждом кластере
Минимизируется сумма расстояний векторов от центров их кластеров. Остановка производится если либо значение данной функции становится ниже некоторого порога, либо мало изменяется по сравнению с предыдущей итерацией.
== Математическое описание алгоритма ==
Дано множество d-мерных векторов  <math>U=\{u_1, u_2, ..., u_n\}</math> и число кластеров <math>k \in \mathbb{N}</math>. Требуется разбить множество <math>U</math> на <math>k</math> непересекающихся непустых кластеров <math>C_1, C_2, ..., C_k</math> таких, что <math>{\bigcup \limits _{i = 1}^k C_i} = U </math>.
 Для этого минимизируется функция <math>
J = \sum\limits_{i=1}^k J_i = \sum\limits_{i=1}^k \sum\limits_{ u \in C_i} \|u-c_i \|^2
</math>, где <math>c_i</math>— центр масс векторов кластера <math>C_i</math>. 
Произвольным образом инициализируем центры кластеров <math>c_1, c_2, ..., c_k</math>, после чего начинается основная часть алгоритма. 
<ul><li>Каждый вектор <math>u_l</math> определяем в ближайший к нему кластер <math>C_i</math>, то есть такой, что
<math>
\|u_l-c_i\|^2 \leqslant \|u_l-c_j\|^2 \;\; \forall i \neq j; \;\; (i,j=1,2,\ldots,k, \; l = 1,2,\ldots,n)
</math>.</li> Хранить информацию о принадлежности векторов кластерам будем в матрице <math>M</math> следующего вида:
:<math>
m_{ij} = \begin{cases}
1, & u_j \in C_i \\
0, & \text{otherwise}
\end{cases}
</math>
<li>Считаем значение функции <math>J</math> и прекращаем работу алгоритма, если это значение меньше заданного порога <math>\varepsilon</math>, либо значение мало изменилось после текущей итерации.</li>
<li>Обновляем значения центров кластеров
:<math>
c_i = \frac{1}{|C_i|} \sum\limits_{u \in C_i} u \;\; (i=1,2,\ldots,k)
</math></li>
<li>Возвращаемся к распределению векторов по кластерам.</li>
</ul>

== Вычислительное ядро алгоритма ==
Вычислительным ядром алгоритма является весь алгоритм, а именно два основных его шага:
<ul><li>Распределение векторов по кластерам</li><li>Пересчёт центров кластеров</li></ul>

== Макроструктура алгоритма ==
Как уже говорилось раньше, первоначальное распределение векторов по кластерам может быть произвольным, например, можно случайным образом выбрать <math>k</math> векторов из множества всех векторов <math>U</math>. 
Далее начинается цикл, его первая операция — распределение векторов по кластерам. В ней для каждого вектора считается расстояние от него, до каждого кластера <math>\rho = \big \| u - c \big \|^2=\sum_{i=1}^d (u_i-c_i)^2</math>, после чего из них выбирается наименьшее и заносится в матрицу. Подсчёт функции <math>J</math> можно проводить одновременно с первым шагом, так как в ней суммируются те же самые расстояния. Пересчёт центров кластеров — сумма всех векторов кластера, делённая на количество объектов в кластере. <math>
c = \frac{1}{|C|} \sum\limits_{u \in C} u
</math>

== Схема реализации последовательного алгоритма ==
<source lang="python">
def kmeans(points, k, cutoff):

# Pick out k random points to use as our initial centroids
initial = random.sample(points, k)

# Create k clusters using those centroids
clusters = [Cluster([p]) for p in initial]

# Loop through the dataset until the clusters stabilize
while True:
# Create a list of lists to hold the points in each cluster
lists = [ [] for c in clusters]

# For every point in the dataset ...
for p in points:
# Get the distance between that point and the centroid of the first cluster.
smallest_distance = getDistance(p, clusters[0].centroid)

# Set the cluster this point belongs to
clusterIndex = 0

# For the remainder of the clusters ...
for i in range(clusterCount - 1):
# calculate the distance of that point to each other cluster's centroid
distance = getDistance(p, clusters[i+1].centroid)
# If it's closer to that cluster's centroid update what we
# think the smallest distance is, and set the point to belong to that cluster
if distance < smallest_distance:
smallest_distance = distance
clusterIndex = i+1
lists[clusterIndex].append(p)

# Set our total_shift to zero for this iteration
total_shift = 0.0

# As many times as there are clusters ...
for i in range(k):
# Calculate how far the centroid moved in this iteration
shift = clusters[i].update(lists[i])
# Keep track of the total moves from all cluster centroid updates
total_shift += shift

# If the centroids have stopped moving much, we're done!
if total_shift < cutoff:
break
return clusters
</source>

== Последовательная сложность алгоритма ==
Распределение по кластерам — для каждого из <math>n</math> векторов и каждого из <math>k</math> кластеров посчитать расстояние, сложив <math>d</math> раз значения, на вычисление каждого из которых нужно 2 операции — <math>O(nkd)</math>. Пересчёт центров — <math>n</math> раз сложить и <math>k</math> раз поделить —  <math>O(n+k)</math>. На завершение алгоритма понадобится <math>i</math> итераций. Итого сложность <math>O(nkdi)</math>.

== Информационный граф ==
На рисунке ниже приведён информационный граф алгоритма. 
[[Файл:HCM graph1.png]]
 
Блок, определяющий ближайший кластер, подробнее. 
[[Файл:HCM_dist1.png]]

== Ресурс параллелизма алгоритма ==
Самой трудоёмкой операцией является распределение по кластерам. Так, для рассчёта расстояний, можно провести суммирование <math>d</math> элементов за <math>log_2(d)</math> операций. Расстояние от данного вектора до всех кластеров можно найти за одну операцию, после чего нужно найти наименьшее значение из <math>k</math> элементов за <math>log_2(k)</math> операций. И всё это нужно сделать для <math>n</math> векторов, что можно сделать параллельно за одну операцию. Для сходимости всё так же потребуется <math>i</math> итераций, общая сложность получается <math>O(log_2(k)log_2(d)i)</math>.

== Входные и выходные данные алгоритма ==
'''Входные данные:'''
*<math>U=\{u_1, u_2, ..., u_n\} \subset \mathbb{R}^d</math> — множество векторов
*<math>k \in \mathbb{N}</math> — количество кластеров
*<math>\varepsilon</math> — порог остановки ''(не обязательно)''.

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

'''Выходные данные:'''
*<math>M</math> — матрица принадлежности векторов кластерам размера <math>nk</math>. При этом данная матрица содержит только <math>n</math> единиц, остальные значения ноль. Возможен вывод в другом виде, например, список списков.

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

== Свойства алгоритма ==
<ul><li>Алгоритм не является детерминированным, так как инициализация кластеров происходит случайным образом, однако, ничто не мешает проводить инициализацию согласно некоторому детерминированному правилу.
</li><li>Алгоритм находит локальный оптимум, поэтому его обычно запускают несколько раз и выбирают лучший результат.</li><li>Вычислительная мощность <math>\frac{kdi}{k+d}</math></li><li>Алгоритм является устойчивым при одинаковой первоначальной инициализации — малая ошибка в начальных данных или при вычислениях очень незначительно повлияют на результат (скорее всего никак не повлияют). Тем не менее, при случайной инициализации результаты будут различны.</li><li>Прост в реализации и вычислениях</li></ul>

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

= Литература =
<ol><li>[http://faculty.petra.ac.id/resmana/private/fuzzy/nfmod.pdf Jan Jantzen «Neurofuzzy Modelling».(Электронное издание)] Technical University of Denmark, Department of Automation, Bldg 326, DK-2800 Lyngby, DENMARK.
Tech. report no 98-H-874 (nfmod), 30 Oct 1998. </li><li>Steinhaus H. (1956). Sur la division des corps materiels en parties. Bull. Acad. Polon. Sci., C1. III vol IV: 801—804.</li><li>Lloyd S. (1957). Least square quantization in PCM’s. Bell Telephone Laboratories Paper.</li><li>MacQueen J. (1967). Some methods for classification and analysis of multivariate observations. In Proc. 5th Berkeley Symp. on Math. Statistics and Probability, pages 281—297.</li></ol>