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

Обсуждение участника:Светлана Лукьяненко

2016-12-19T09:47:50Z

Юрий Комаров: /* Статья Участник:Светлана Лукьяненко/Строгий алгоритм С средних (Hard C-Means, HCM) */

= Статья [[Участник:Светлана Лукьяненко/Строгий алгоритм С средних (Hard C-Means, HCM)]] =

* Там действительно надо O(N*C) итераций или это какая-то оценка сверху? Откуда она взялась, кроме соображений того, что при превышении алгоритм бы был неэффективен? [[Участник:Chalker|Chalker]] ([[Обсуждение участника:Chalker|обсуждение]]) 23:22, 18 декабря 2016 (MSK)
** Исключительно из этих соображений, поскольку скорость сходимости алгоритма не определена. Более того, где-то в тексте было упомянуто, что к действительному минимуму он может не сходиться. [[Участник:Юрий Комаров|Комаров Юрий]]
** Исправлено введением числа итераций в явном виде и их включением в оценки сложности и высоты япф.
* Ни ширина, ни высота не зависят от размерности векторов? [[Участник:Chalker|Chalker]] ([[Обсуждение участника:Chalker|обсуждение]]) 23:15, 18 декабря 2016 (MSK)
** Учтено. [[Участник:Юрий Комаров|Комаров Юрий]]
* «получаем итоговую сложность последовательной реализации алгоритма O(nNc) {\displaystyle O(nNc)} (в предположении, что n {\displaystyle n} и C {\displaystyle C} существенно меньше N {\displaystyle N})» — что имелось ввиду? [[Участник:Chalker|Chalker]] ([[Обсуждение участника:Chalker|обсуждение]]) 23:15, 18 декабря 2016 (MSK)
* 1.6 — «Ожидая, что предельная точность будет достигнута менее, чем за N итераций…» — у вас получается сложность алгоритма тогда не O(N), а O(N*сложность итерации), если итераций N штук. В литературе есть какие-то оценки требуемого количества итераций исходя из входных параметров? [[Участник:Chalker|Chalker]] ([[Обсуждение участника:Chalker|обсуждение]]) 18:21, 18 декабря 2016 (MSK)
** нет, оценок нет, поэтому предлагается оценить через O(NC) [[Участник:Юрий Комаров|Комаров Юрий]]
* 1.8 — высота не равна O(1) на вашем графе, она зависит в том числе от N. [[Участник:Chalker|Chalker]] ([[Обсуждение участника:Chalker|обсуждение]]) 23:48, 17 декабря 2016 (MSK)
* 1.6 — сложность не равна O(N), у вас одних только операций умножения строчкой выше O(nNC). [[Участник:Chalker|Chalker]] ([[Обсуждение участника:Chalker|обсуждение]]) 23:48, 17 декабря 2016 (MSK)
** Согласен, O(nNC). [[Участник:Юрий Комаров|Комаров Юрий]]

----

* Не указан вклад каждого автора [[Участник: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-12-18T20:45:22Z

Юрий Комаров: /* Ресурс параллелизма алгоритма */

{{assignment|{{REVISIONUSER}}}}

{{algorithm
| name = Строгий алгоритм С средних (Hard C-Means,HCM)
| serial_complexity = <math>O(nNCi)</math>
| pf_height = <math>O(ilog_2(NC))</math>
| pf_width = <math>O(nNC)</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>i</math> итераций, получаем итоговую сложность последовательной реализации алгоритма <math>O(nNCi)</math>.

Отметим, что ввиду сделанных замечаний, построить сколько-нибудь точную оценку числа итераций <math>i</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(nNC)</math> (<math>N</math> блоков <math>d</math>, в каждом из которых независимо выполняются <math>C</math> операций вычислений квадратов норм, каждая из которых предполагает ширину не более <math>n</math>).

Высота одной итерации алгоритма оценивается через <math>log_2(NC)</math> (<math>N</math> сложений для расчёта <math>J</math> можно провести за <math>log_2(N)</math> операций, сложность блока <math>d</math> равна <math>O(log_2(C))</math>). Полагая, что число итераций равно <math>i</math>, получаем итоговую высоту ярусно-параллельной формы алгоритма: <math>ilog_2(NC)</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 />

Участник:Светлана Лукьяненко/Строгий алгоритм С средних (Hard C-Means, HCM)

2016-12-18T20:44:46Z

Юрий Комаров: /* Ресурс параллелизма алгоритма */

{{assignment|{{REVISIONUSER}}}}

{{algorithm
| name = Строгий алгоритм С средних (Hard C-Means,HCM)
| serial_complexity = <math>O(nNCi)</math>
| pf_height = <math>O(ilog_2(NC))</math>
| pf_width = <math>O(nNC)</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>i</math> итераций, получаем итоговую сложность последовательной реализации алгоритма <math>O(nNCi)</math>.

Отметим, что ввиду сделанных замечаний, построить сколько-нибудь точную оценку числа итераций <math>i</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(nNC)</math> (<math>N</math> блоков <math>d</math>, в каждом из которых независимо выполняются <math>C</math> операций вычислений квадратов норм, каждая из которых предполагает ширину не более <math>n</math>).

Высота одной итерации алгоритма оценивается через <math>log_2(NC)</math> (<math>N</math> сложений для расчёта <math>J</math> можно провести за <math>log_2(N)</math> операций, сложность блока <math>d</math> равна <math>log_2(C) + 1</math>). Полагая, что число итераций равно <math>i</math>, получаем итоговую высоту ярусно-параллельной формы алгоритма: <math>ilog_2(NC)</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 />

Участник:Светлана Лукьяненко/Строгий алгоритм С средних (Hard C-Means, HCM)

2016-12-18T20:42:55Z

Юрий Комаров: /* Последовательная сложность алгоритма */

{{assignment|{{REVISIONUSER}}}}

{{algorithm
| name = Строгий алгоритм С средних (Hard C-Means,HCM)
| serial_complexity = <math>O(nNCi)</math>
| pf_height = <math>O(ilog_2(NC))</math>
| pf_width = <math>O(nNC)</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>i</math> итераций, получаем итоговую сложность последовательной реализации алгоритма <math>O(nNCi)</math>.

Отметим, что ввиду сделанных замечаний, построить сколько-нибудь точную оценку числа итераций <math>i</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(nNC)</math> (<math>N</math> блоков <math>d</math>, в каждом из которых независимо выполняются <math>C</math> операций вычислений квадратов норм, каждая из которых предполагает ширину не более <math>n</math>).

Высота одной итерации алгоритма оценивается через <math>log_2(NC)</math> (<math>N</math> сложений для расчёта <math>J</math> можно провести за <math>log_2(N)</math> операций, сложность блока <math>d</math> равна <math>log_2(C) + 1</math>). Число итераций может быть оценено как <math>O(NC)</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 />

Участник:Светлана Лукьяненко/Строгий алгоритм С средних (Hard C-Means, HCM)

2016-12-18T20:42:31Z

Юрий Комаров: /* Последовательная сложность алгоритма */

{{assignment|{{REVISIONUSER}}}}

{{algorithm
| name = Строгий алгоритм С средних (Hard C-Means,HCM)
| serial_complexity = <math>O(nNCi)</math>
| pf_height = <math>O(ilog_2(NC))</math>
| pf_width = <math>O(nNC)</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>i</math> итераций, получаем итоговую сложность последовательной реализации алгоритма <math>O(nNC)</math>.

Отметим, что ввиду сделанных замечаний, построить сколько-нибудь точную оценку числа итераций <math>i</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(nNC)</math> (<math>N</math> блоков <math>d</math>, в каждом из которых независимо выполняются <math>C</math> операций вычислений квадратов норм, каждая из которых предполагает ширину не более <math>n</math>).

Высота одной итерации алгоритма оценивается через <math>log_2(NC)</math> (<math>N</math> сложений для расчёта <math>J</math> можно провести за <math>log_2(N)</math> операций, сложность блока <math>d</math> равна <math>log_2(C) + 1</math>). Число итераций может быть оценено как <math>O(NC)</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 />

Участник:Светлана Лукьяненко/Строгий алгоритм С средних (Hard C-Means, HCM)

2016-12-18T20:40:04Z

Юрий Комаров:

{{assignment|{{REVISIONUSER}}}}

{{algorithm
| name = Строгий алгоритм С средних (Hard C-Means,HCM)
| serial_complexity = <math>O(nNCi)</math>
| pf_height = <math>O(ilog_2(NC))</math>
| pf_width = <math>O(nNC)</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(nNC)</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(nNC)</math> (<math>N</math> блоков <math>d</math>, в каждом из которых независимо выполняются <math>C</math> операций вычислений квадратов норм, каждая из которых предполагает ширину не более <math>n</math>).

Высота одной итерации алгоритма оценивается через <math>log_2(NC)</math> (<math>N</math> сложений для расчёта <math>J</math> можно провести за <math>log_2(N)</math> операций, сложность блока <math>d</math> равна <math>log_2(C) + 1</math>). Число итераций может быть оценено как <math>O(NC)</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-12-18T20:33:51Z

Юрий Комаров: /* Статья Участник:Светлана Лукьяненко/Строгий алгоритм С средних (Hard C-Means, HCM) */

= Статья [[Участник:Светлана Лукьяненко/Строгий алгоритм С средних (Hard C-Means, HCM)]] =

* Там действительно надо O(N*C) итераций или это какая-то оценка сверху? Откуда она взялась, кроме соображений того, что при превышении алгоритм бы был неэффективен? [[Участник:Chalker|Chalker]] ([[Обсуждение участника:Chalker|обсуждение]]) 23:22, 18 декабря 2016 (MSK)
** Исключительно из этих соображений, поскольку скорость сходимости алгоритма не определена. Более того, где-то в тексте было упомянуто, что к действительному минимуму он может не сходиться. [[Участник:Юрий Комаров|Комаров Юрий]]
* Ни ширина, ни высота не зависят от размерности векторов? [[Участник:Chalker|Chalker]] ([[Обсуждение участника:Chalker|обсуждение]]) 23:15, 18 декабря 2016 (MSK)
** Учтено. [[Участник:Юрий Комаров|Комаров Юрий]]
* «получаем итоговую сложность последовательной реализации алгоритма O(nNc) {\displaystyle O(nNc)} (в предположении, что n {\displaystyle n} и C {\displaystyle C} существенно меньше N {\displaystyle N})» — что имелось ввиду? [[Участник:Chalker|Chalker]] ([[Обсуждение участника:Chalker|обсуждение]]) 23:15, 18 декабря 2016 (MSK)
* 1.6 — «Ожидая, что предельная точность будет достигнута менее, чем за N итераций…» — у вас получается сложность алгоритма тогда не O(N), а O(N*сложность итерации), если итераций N штук. В литературе есть какие-то оценки требуемого количества итераций исходя из входных параметров? [[Участник:Chalker|Chalker]] ([[Обсуждение участника:Chalker|обсуждение]]) 18:21, 18 декабря 2016 (MSK)
** нет, оценок нет, поэтому предлагается оценить через O(NC) [[Участник:Юрий Комаров|Комаров Юрий]]
* 1.8 — высота не равна O(1) на вашем графе, она зависит в том числе от N. [[Участник:Chalker|Chalker]] ([[Обсуждение участника:Chalker|обсуждение]]) 23:48, 17 декабря 2016 (MSK)
* 1.6 — сложность не равна O(N), у вас одних только операций умножения строчкой выше O(nNC). [[Участник:Chalker|Chalker]] ([[Обсуждение участника:Chalker|обсуждение]]) 23:48, 17 декабря 2016 (MSK)
** Согласен, O(nNC). [[Участник:Юрий Комаров|Комаров Юрий]]

----

* Не указан вклад каждого автора [[Участник: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-12-18T20:29:31Z

Юрий Комаров:

{{assignment|{{REVISIONUSER}}}}

{{algorithm
| name = Строгий алгоритм С средних (Hard C-Means,HCM)
| serial_complexity = <math>O(nNC)</math>
| pf_height = <math>O(NClog_2(NC))</math>
| pf_width = <math>O(nNC)</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(nNC)</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(nNC)</math> (<math>N</math> блоков <math>d</math>, в каждом из которых независимо выполняются <math>C</math> операций вычислений квадратов норм, каждая из которых предполагает ширину не более <math>n</math>).

Высота одной итерации алгоритма оценивается через <math>log_2(NC)</math> (<math>N</math> сложений для расчёта <math>J</math> можно провести за <math>log_2(N)</math> операций, сложность блока <math>d</math> равна <math>log_2(C) + 1</math>). Число итераций может быть оценено как <math>O(NC)</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 />

Участник:Светлана Лукьяненко/Строгий алгоритм С средних (Hard C-Means, HCM)

2016-12-18T20:29:07Z

Юрий Комаров: /* Ресурс параллелизма алгоритма */

{{assignment|{{REVISIONUSER}}}}

{{algorithm
| name = Строгий алгоритм С средних (Hard C-Means,HCM)
| serial_complexity = <math>O(nNC)</math>
| pf_height = <math>O(NClog_2(NC))</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(nNC)</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(nNC)</math> (<math>N</math> блоков <math>d</math>, в каждом из которых независимо выполняются <math>C</math> операций вычислений квадратов норм, каждая из которых предполагает ширину не более <math>n</math>).

Высота одной итерации алгоритма оценивается через <math>log_2(NC)</math> (<math>N</math> сложений для расчёта <math>J</math> можно провести за <math>log_2(N)</math> операций, сложность блока <math>d</math> равна <math>log_2(C) + 1</math>). Число итераций может быть оценено как <math>O(NC)</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 />

Участник:Светлана Лукьяненко/Строгий алгоритм С средних (Hard C-Means, HCM)

2016-12-18T20:19:37Z

Юрий Комаров: /* Последовательная сложность алгоритма */

{{assignment|{{REVISIONUSER}}}}

{{algorithm
| name = Строгий алгоритм С средних (Hard C-Means,HCM)
| serial_complexity = <math>O(nNC)</math>
| pf_height = <math>O(NClog_2(NC))</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(nNC)</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>).

Высота одной итерации алгоритма оценивается через <math>log_2(NC)</math> (<math>N</math> сложений для расчёта <math>J</math> можно провести за <math>log_2(N)</math> операций, сложность блока <math>d</math> равна <math>log_2(C) + 1</math>). Число итераций может быть оценено как <math>O(NC)</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-12-18T16:01:45Z

Юрий Комаров:

= Статья [[Участник:Светлана Лукьяненко/Строгий алгоритм С средних (Hard C-Means, HCM)]] =

* 1.6 — «Ожидая, что предельная точность будет достигнута менее, чем за N итераций…» — у вас получается сложность алгоритма тогда не O(N), а O(N*сложность итерации), если итераций N штук. В литературе есть какие-то оценки требуемого количества итераций исходя из входных параметров? [[Участник:Chalker|Chalker]] ([[Обсуждение участника:Chalker|обсуждение]]) 18:21, 18 декабря 2016 (MSK)
** нет, оценок нет, поэтому предлагается оценить через O(NC) [[Участник:Юрий Комаров|Комаров Юрий]]
* 1.8 — высота не равна O(1) на вашем графе, она зависит в том числе от N. [[Участник:Chalker|Chalker]] ([[Обсуждение участника:Chalker|обсуждение]]) 23:48, 17 декабря 2016 (MSK)
* 1.6 — сложность не равна O(N), у вас одних только операций умножения строчкой выше O(nNC). [[Участник:Chalker|Chalker]] ([[Обсуждение участника:Chalker|обсуждение]]) 23:48, 17 декабря 2016 (MSK)
** Согласен, O(nNC). [[Участник:Юрий Комаров|Комаров Юрий]]

----

* Не указан вклад каждого автора [[Участник: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)

Обсуждение участника:Светлана Лукьяненко

2016-12-18T15:58:06Z

Юрий Комаров: /* Статья Участник:Светлана Лукьяненко/Строгий алгоритм С средних (Hard C-Means, HCM) */

= Статья [[Участник:Светлана Лукьяненко/Строгий алгоритм С средних (Hard C-Means, HCM)]] =

* 1.6 — «Ожидая, что предельная точность будет достигнута менее, чем за N итераций…» — у вас получается сложность алгоритма тогда не O(N), а O(N*сложность итерации), если итераций N штук. В литературе есть какие-то оценки требуемого количества итераций исходя из входных параметров? [[Участник:Chalker|Chalker]] ([[Обсуждение участника:Chalker|обсуждение]]) 18:21, 18 декабря 2016 (MSK)
** нет, оценок нет, поэтому предлагается оценить через O(NC) [[Участник:Юрий Комаров|Комаров Юрий]]
* 1.8 — высота не равна O(1) на вашем графе, она зависит в том числе от N. [[Участник:Chalker|Chalker]] ([[Обсуждение участника:Chalker|обсуждение]]) 23:48, 17 декабря 2016 (MSK)
* 1.6 — сложность не равна O(N), у вас одних только операций умножения строчкой выше O(nNC). [[Участник:Chalker|Chalker]] ([[Обсуждение участника:Chalker|обсуждение]]) 23:48, 17 декабря 2016 (MSK)

----

* Не указан вклад каждого автора [[Участник: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-12-18T15:56:29Z

Юрий Комаров:

{{assignment|{{REVISIONUSER}}}}

{{algorithm
| name = Строгий алгоритм С средних (Hard C-Means,HCM)
| serial_complexity = <math>O(nNC)</math>
| pf_height = <math>O(NClog_2(NC))</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(nNc)</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>).

Высота одной итерации алгоритма оценивается через <math>log_2(NC)</math> (<math>N</math> сложений для расчёта <math>J</math> можно провести за <math>log_2(N)</math> операций, сложность блока <math>d</math> равна <math>log_2(C) + 1</math>). Число итераций может быть оценено как <math>O(NC)</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 />

Участник:Светлана Лукьяненко/Строгий алгоритм С средних (Hard C-Means, HCM)

2016-12-18T15:55:22Z

Юрий Комаров: /* Ресурс параллелизма алгоритма */

{{assignment|{{REVISIONUSER}}}}

{{algorithm
| name = Строгий алгоритм С средних (Hard C-Means,HCM)
| serial_complexity = <math>O(nNC)</math>
| pf_height = <math>O(NC)</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(nNc)</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>).

Высота одной итерации алгоритма оценивается через <math>log_2(NC)</math> (<math>N</math> сложений для расчёта <math>J</math> можно провести за <math>log_2(N)</math> операций, сложность блока <math>d</math> равна <math>log_2(C) + 1</math>). Число итераций может быть оценено как <math>O(NC)</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 />

Участник:Светлана Лукьяненко/Строгий алгоритм С средних (Hard C-Means, HCM)

2016-12-18T15:32:31Z

Юрий Комаров:

{{assignment|{{REVISIONUSER}}}}

{{algorithm
| name = Строгий алгоритм С средних (Hard C-Means,HCM)
| serial_complexity = <math>O(nNC)</math>
| pf_height = <math>O(NC)</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(nNc)</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(N)</math> на высоту каждой итерации <math>O(C)</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 />

Участник:Светлана Лукьяненко/Строгий алгоритм С средних (Hard C-Means, HCM)

2016-12-18T15:32:10Z

Юрий Комаров:

{{assignment|{{REVISIONUSER}}}}

{{algorithm
| name = Строгий алгоритм С средних (Hard C-Means,HCM)
| serial_complexity = <math>O(nNC)</math>
| pf_height = <math>O(NcC)</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(nNc)</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(N)</math> на высоту каждой итерации <math>O(c)</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 />

Участник:Светлана Лукьяненко/Строгий алгоритм С средних (Hard C-Means, HCM)

2016-12-18T15:31:35Z

Юрий Комаров:

{{assignment|{{REVISIONUSER}}}}

{{algorithm
| name = Строгий алгоритм С средних (Hard C-Means,HCM)
| serial_complexity = <math>O(nNc)</math>
| pf_height = <math>O(Nc)</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(nNc)</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(N)</math> на высоту каждой итерации <math>O(c)</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 />

Участник:Светлана Лукьяненко/Строгий алгоритм С средних (Hard C-Means, HCM)

2016-12-18T15:05:48Z

Юрий Комаров:

{{assignment|{{REVISIONUSER}}}}

{{algorithm
| name = Строгий алгоритм С средних (Hard C-Means,HCM)
| serial_complexity = <math>O(N)</math>
| pf_height = <math>O(N)</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(N)</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 />

Участник:Светлана Лукьяненко/Строгий алгоритм С средних (Hard C-Means, HCM)

2016-11-22T14:07:55Z

Юрий Комаров:

{{assignment}}

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

Участник:Светлана Лукьяненко/Строгий алгоритм С средних (Hard C-Means, HCM)

2016-11-22T14:07:31Z

Юрий Комаров: /* Масштабируемость алгоритма и его реализации */

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

Участник:Светлана Лукьяненко/Строгий алгоритм С средних (Hard C-Means, HCM)

2016-11-22T10:24:50Z

Юрий Комаров:

{{assignment}}

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

Участник:Светлана Лукьяненко/Строгий алгоритм С средних (Hard C-Means, HCM)

2016-11-22T10:23:50Z

Юрий Комаров: /* Масштабируемость алгоритма и его реализации */

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

Участник:Светлана Лукьяненко/Строгий алгоритм С средних (Hard C-Means, HCM)

2016-11-15T17:34:31Z

Юрий Комаров:

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

Участник:Светлана Лукьяненко/Строгий алгоритм С средних (Hard C-Means, HCM)

2016-11-15T17:33:36Z

Юрий Комаров: /* Масштабируемость алгоритма и его реализации */

{{Assignment|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.7), [[Участник:Юрий_Комаров|Комаров Юрий]](1.2, 1.5, 1.6, 1.7, 1.8, 1.9)

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

=== Общее описание алгоритма ===
'''Строгий алгоритм 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 />

Участник:Светлана Лукьяненко/Строгий алгоритм С средних (Hard C-Means, HCM)

2016-11-02T17:36:51Z

Юрий Комаров:

{{assignment}}

{{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.7), [[Участник:Юрий_Комаров|Комаров Юрий]](1.2, 1.5, 1.6, 1.7, 1.8, 1.9)

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

=== Общее описание алгоритма ===
'''Строгий алгоритм 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>.

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

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

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

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

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

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

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

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

Обсуждение участника:Светлана Лукьяненко

2016-10-30T19:53:17Z

Юрий Комаров:

= Статья [[Строгий алгоритм С средних (Hard C-Means, HCM)]] =
* Не указан вклад каждого автора [[Участник:Coctic|Coctic]] ([[Обсуждение участника:Coctic|обсуждение]]) 10:57, 25 октября 2016 (MSK)
* Значительная часть п. 1.2 совпадает с тем же пунктом из [[Участник:Каледа Александр/Строгий алгоритм С средних (Hard C-Means)]] [[Участник:Coctic|Coctic]] ([[Обсуждение участника:Coctic|обсуждение]]) 11:05, 25 октября 2016 (MSK)
* В списке литературы отсутствуют выходные данные публикаций, кроме названия и автора. По приведенным данным определить конкретную публикацию не представляется возможным. Стоит добавить ссылку на оригинальную публикацию с описанием алгоритма, упомянутую в начале п.1.1 [[Участник:Coctic|Coctic]] ([[Обсуждение участника:Coctic|обсуждение]]) 10:57, 25 октября 2016 (MSK)
* Список литературы совпадает со списком из [[Участник:Каледа Александр/Строгий алгоритм С средних (Hard C-Means)]] [[Участник:Coctic|Coctic]] ([[Обсуждение участника:Coctic|обсуждение]]) 11:01, 25 октября 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 октября), должны не мы, а указанные личности. К сожалению, заставить их это сделать мы не можем, полагаю, регулирование этого вопроса нам разумнее доверить проверяющим.

Участник:Светлана Лукьяненко/Строгий алгоритм С средних (Hard C-Means, HCM)

2016-10-30T19:48:49Z

Юрий Комаров:

{{Assignment}}

{{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.7), [[Участник:Юрий_Комаров|Комаров Юрий]](1.2, 1.5, 1.6, 1.7, 1.8, 1.9)

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

=== Общее описание алгоритма ===
'''Строгий алгоритм C средних''' ('''''Hard C-Means'''''; ''Jang, Sun and Mizutani, 1997'') позволяет распределить большие наборы числовых данных по кластерам в многомерном пространстве<ref>[http://faculty.petra.ac.id/resmana/private/fuzzy/nfmod.pdf Jan Jantzen «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 Нейский И.М. Классификация и сравнение методов кластеризации.]</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>.

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

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

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

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

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

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

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

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

Участник:Светлана Лукьяненко/Строгий алгоритм С средних (Hard C-Means, HCM)

2016-10-28T13:55:54Z

Юрий Комаров: /* Свойства алгоритма */

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

Авторы описания: [[Участник:Светлана_Лукьяненко|Лукьяненко Светлана]], [[Участник:Юрий_Комаров|Комаров Юрий]].

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

=== Общее описание алгоритма ===
'''Строгий алгоритм C средних''' ('''''Hard C-Means'''''; ''Jang, Sun and Mizutani, 1997'') позволяет распределить большие наборы числовых данных по кластерам в многомерном пространстве<ref>Jan Jantzen «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> Нейский И.М. Классификация и сравнение методов кластеризации.</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>.

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

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

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

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

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

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

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

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

Обсуждение участника:Светлана Лукьяненко

2016-10-25T15:32:29Z

Юрий Комаров:

Участник:Светлана Лукьяненко/Строгий алгоритм С средних (Hard C-Means, HCM)

2016-10-15T19:55:27Z

Юрий Комаров: /* Информационный граф */

{{Assignment}}

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

Авторы описания: [[Участник:Светлана_Лукьяненко|Лукьяненко Светлана]], [[Участник:Юрий_Комаров|Комаров Юрий]].

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

=== Общее описание алгоритма ===
'''Строгий алгоритм C средних''' ('''''Hard C-Means'''''; ''Jang, Sun and Mizutani, 1997'') позволяет распределить большие наборы числовых данных по кластерам в многомерном пространстве<ref>Jan Jantzen «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> Нейский И.М. Классификация и сравнение методов кластеризации.</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>.

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

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

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

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

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

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

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

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

Участник:Светлана Лукьяненко/Строгий алгоритм С средних (Hard C-Means, HCM)

2016-10-15T07:25:43Z

Юрий Комаров: /* Информационный граф */

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

Авторы описания: [[Участник:Светлана_Лукьяненко|Лукьяненко Светлана]], [[Участник:Юрий_Комаров|Комаров Юрий]].

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

=== Общее описание алгоритма ===
'''Строгий алгоритм C средних''' ('''''Hard C-Means'''''; ''Jang, Sun and Mizutani, 1997'') позволяет распределить большие наборы числовых данных по кластерам в многомерном пространстве<ref>Jan Jantzen «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> Нейский И.М. Классификация и сравнение методов кластеризации.</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''''', ей соответствует операция записи 1 в столбец, отвечающий ветке графа, в позицию, полученную на предыдущем шаге и соответствующую ближайшему кластерному центру.

'''Третья''' вершина отмечена символом '''''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''''' — прямое вычисление расстояния до кластерных центров, '''''max''''' — вычисление максимума двух чисел (с сохранением соответствующего максимуму кластерного индекса) и '''''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>.

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

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

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

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

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

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

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

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

Участник:Светлана Лукьяненко/Строгий алгоритм С средних (Hard C-Means, HCM)

2016-10-14T20:40:53Z

Юрий Комаров: /* Макроструктура алгоритма */

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

Авторы описания: [[Участник:Светлана_Лукьяненко|Лукьяненко Светлана]], [[Участник:Юрий_Комаров|Комаров Юрий]].

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

=== Общее описание алгоритма ===
'''Строгий алгоритм C средних''' ('''''Hard C-Means'''''; ''Jang, Sun and Mizutani, 1997'') позволяет распределить большие наборы числовых данных по кластерам в многомерном пространстве<ref>Jan Jantzen «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> Нейский И.М. Классификация и сравнение методов кластеризации.</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''''', ей соответствует операция записи 1 в столбец, отвечающий ветке графа, в позицию, полученную на предыдущем шаге и соответствующую ближайшему кластерному центру.

'''Третья''' вершина отмечена символом '''''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>), '''''d1,...,dC''''' — прямое вычисление расстояния до кластерных центров, '''''max''''' — вычисление максимума двух чисел (с сохранением соответствующего максимуму кластерного индекса) и '''''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>.

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

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

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

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

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

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

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

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

Участник:Светлана Лукьяненко/Строгий алгоритм С средних (Hard C-Means, HCM)

2016-10-14T20:38:07Z

Юрий Комаров: /* Информационный граф */ Добавлено текстовое описание

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

Авторы описания: [[Участник:Светлана_Лукьяненко|Лукьяненко Светлана]], [[Участник:Юрий_Комаров|Комаров Юрий]].

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

=== Общее описание алгоритма ===
'''Строгий алгоритм C средних''' ('''''Hard C-Means'''''; ''Jang, Sun and Mizutani, 1997'') позволяет распределить большие наборы числовых данных по кластерам в многомерном пространстве<ref>Jan Jantzen «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> Нейский И.М. Классификация и сравнение методов кластеризации.</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''''', ей соответствует операция записи 1 в столбец, отвечающий ветке графа, в позицию, полученную на предыдущем шаге и соответствующую ближайшему кластерному центру.

'''Третья''' вершина отмечена символом '''''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>), '''''d1,...,dC''''' — прямое вычисление расстояния до кластерных центров, '''''max''''' — вычисление максимума двух чисел (с сохранением соответствующего максимуму кластерного индекса) и '''''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>.

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

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

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

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

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

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

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

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

Участник:Светлана Лукьяненко/Строгий алгоритм С средних (Hard C-Means, HCM)

2016-10-14T20:08:27Z

Юрий Комаров: /* Существующие реализации алгоритма */

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

Авторы описания: [[Участник:Светлана_Лукьяненко|Лукьяненко Светлана]], [[Участник:Юрий_Комаров|Комаров Юрий]].

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

=== Общее описание алгоритма ===
'''Строгий алгоритм C средних''' ('''''Hard C-Means'''''; ''Jang, Sun and Mizutani, 1997'') позволяет распределить большие наборы числовых данных по кластерам в многомерном пространстве<ref>Jan Jantzen «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> Нейский И.М. Классификация и сравнение методов кластеризации.</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>).

=== Информационный граф ===
[[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>), '''''d1,...,dC''''' — прямое вычисление расстояния до кластерных центров, '''''max''''' — вычисление максимума двух чисел (с сохранением соответствующего максимуму кластерного индекса) и '''''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>.

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

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

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

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

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

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

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

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

Участник:Светлана Лукьяненко/Строгий алгоритм С средних (Hard C-Means, HCM)

2016-10-14T20:02:56Z

Юрий Комаров:

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

Авторы описания: [[Участник:Светлана_Лукьяненко|Лукьяненко Светлана]], [[Участник:Юрий_Комаров|Комаров Юрий]].

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

=== Общее описание алгоритма ===
'''Строгий алгоритм C средних''' ('''''Hard C-Means'''''; ''Jang, Sun and Mizutani, 1997'') позволяет распределить большие наборы числовых данных по кластерам в многомерном пространстве<ref>Jan Jantzen «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> Нейский И.М. Классификация и сравнение методов кластеризации.</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>).

=== Информационный граф ===
[[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>), '''''d1,...,dC''''' — прямое вычисление расстояния до кластерных центров, '''''max''''' — вычисление максимума двух чисел (с сохранением соответствующего максимуму кластерного индекса) и '''''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>.

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

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

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

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

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

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

Параллельных реализаций в свободном доступе обнаружено не было.

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

Участник:Светлана Лукьяненко/Строгий алгоритм С средних (Hard C-Means, HCM)

2016-10-14T20:01:42Z

Юрий Комаров: /* Ресурс параллелизма алгоритма */

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

Авторы описания: [[Участник:Светлана_Лукьяненко|Лукьяненко Светлана]], [[Участник:Юрий_Комаров|Комаров Юрий]].

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

=== Общее описание алгоритма ===
'''Строгий алгоритм C средних''' ('''''Hard C-Means'''''; ''Jang, Sun and Mizutani, 1997'') позволяет распределить большие наборы числовых данных по кластерам в многомерном пространстве<ref>Jan Jantzen «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> Нейский И.М. Классификация и сравнение методов кластеризации.</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>).

=== Информационный граф ===
[[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>), '''''d1,...,dC''''' — прямое вычисление расстояния до кластерных центров, '''''max''''' — вычисление максимума двух чисел (с сохранением соответствующего максимуму кластерного индекса) и '''''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>.

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

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

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

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

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

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

Параллельных реализаций в свободном доступе обнаружено не было.

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

Участник:Светлана Лукьяненко/Строгий алгоритм С средних (Hard C-Means, HCM)

2016-10-14T19:47:12Z

Юрий Комаров: /* Последовательная сложность алгоритма */

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

Авторы описания: [[Участник:Светлана_Лукьяненко|Лукьяненко Светлана]], [[Участник:Юрий_Комаров|Комаров Юрий]].

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

=== Общее описание алгоритма ===
'''Строгий алгоритм C средних''' ('''''Hard C-Means'''''; ''Jang, Sun and Mizutani, 1997'') позволяет распределить большие наборы числовых данных по кластерам в многомерном пространстве<ref>Jan Jantzen «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> Нейский И.М. Классификация и сравнение методов кластеризации.</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>).

=== Информационный граф ===
[[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>), '''''d1,...,dC''''' — прямое вычисление расстояния до кластерных центров, '''''max''''' — вычисление максимума двух чисел (с сохранением соответствующего максимуму кластерного индекса) и '''''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>\{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>.

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

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

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

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

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

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

Параллельных реализаций в свободном доступе обнаружено не было.

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

Участник:Светлана Лукьяненко/Строгий алгоритм С средних (Hard C-Means, HCM)

2016-10-14T19:38:07Z

Юрий Комаров:

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

Авторы описания: [[Участник:Светлана_Лукьяненко|Лукьяненко Светлана]], [[Участник:Юрий_Комаров|Комаров Юрий]].

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

=== Общее описание алгоритма ===
'''Строгий алгоритм C средних''' ('''''Hard C-Means'''''; ''Jang, Sun and Mizutani, 1997'') позволяет распределить большие наборы числовых данных по кластерам в многомерном пространстве<ref>Jan Jantzen «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> Нейский И.М. Классификация и сравнение методов кластеризации.</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>(2n-1)NC</math> арифметических операций сложения и вычитания;
* <math>(3+(n+1)C)N</math> операций умножения.

Ожидая, что предельная точность будет достигнута менее, чем за <math>N</math> итераций (в противном случае применение алгоритма можно считать нецелесообразным), получаем итоговую сложность последовательной реализации алгоритма <math>O(N)</math> (в предположении, что <math>n</math> и <math>C</math> существенно меньше <math>N</math>).

=== Информационный граф ===
[[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>), '''''d1,...,dC''''' — прямое вычисление расстояния до кластерных центров, '''''max''''' — вычисление максимума двух чисел (с сохранением соответствующего максимуму кластерного индекса) и '''''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>\{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>.

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

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

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

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

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

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

Параллельных реализаций в свободном доступе обнаружено не было.

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

Участник:Светлана Лукьяненко/Строгий алгоритм С средних (Hard C-Means, HCM)

2016-10-14T19:35:07Z

Юрий Комаров: /* Входные и выходные данные алгоритма */

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

Авторы описания: [[Участник:Светлана_Лукьяненко|Лукьяненко Светлана]], [[Участник:Юрий_Комаров|Комаров Юрий]].

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

=== Общее описание алгоритма ===
'''Строгий алгоритм C средних''' ('''''Hard C-Means'''''; ''Jang, Sun and Mizutani, 1997'') позволяет распределить большие наборы числовых данных по кластерам в многомерном пространстве<ref>Jan Jantzen «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> Нейский И.М. Классификация и сравнение методов кластеризации.</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>(2n-1)NC</math> арифметических операций сложения и вычитания;
* <math>(3+(n+1)C)N</math> операций умножения.

Ожидая, что предельная точность будет достигнута менее, чем за <math>N</math> итераций (в противном случае применение алгоритма можно считать нецелесообразным), получаем итоговую сложность последовательной реализации алгоритма <math>O(N)</math> (в предположении, что <math>n</math> и <math>C</math> существенно меньше <math>N</math>).

=== Информационный граф ===
[[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>), '''''d1,...,dC''''' — прямое вычисление расстояния до кластерных центров, '''''max''''' — вычисление максимума двух чисел (с сохранением соответствующего максимуму кластерного индекса) и '''''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>\{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>.

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

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

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

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

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

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

Параллельных реализаций в свободном доступе обнаружено не было.

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

Участник:Светлана Лукьяненко/Строгий алгоритм С средних (Hard C-Means, HCM)

2016-10-14T19:32:34Z

Юрий Комаров: /* Ресурс параллелизма алгоритма */

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

Авторы описания: [[Участник:Светлана_Лукьяненко|Лукьяненко Светлана]], [[Участник:Юрий_Комаров|Комаров Юрий]].

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

=== Общее описание алгоритма ===
'''Строгий алгоритм C средних''' ('''''Hard C-Means'''''; ''Jang, Sun and Mizutani, 1997'') позволяет распределить большие наборы числовых данных по кластерам в многомерном пространстве<ref>Jan Jantzen «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> Нейский И.М. Классификация и сравнение методов кластеризации.</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>(2n-1)NC</math> арифметических операций сложения и вычитания;
* <math>(3+(n+1)C)N</math> операций умножения.

Ожидая, что предельная точность будет достигнута менее, чем за <math>N</math> итераций (в противном случае применение алгоритма можно считать нецелесообразным), получаем итоговую сложность последовательной реализации алгоритма <math>O(N)</math> (в предположении, что <math>n</math> и <math>C</math> существенно меньше <math>N</math>).

=== Информационный граф ===
[[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>), '''''d1,...,dC''''' — прямое вычисление расстояния до кластерных центров, '''''max''''' — вычисление максимума двух чисел (с сохранением соответствующего максимуму кластерного индекса) и '''''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>\{u_k\}_{k=1}^{n} \subset \mathbb{R}^m</math> — исходный набор векторов;
*<math>c</math> — желаемое количество кластеров (<math>2 \leqslant c \leqslant n</math>);
* ''(опционально)'' <math>\varepsilon_{tr}</math> — пороговая точность работы алгоритма.

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

'''Выходные данные:'''
*<math>M</math> — рядовая матрица из пространства <math>\mathbb{R}^{c \times n}</math>.

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

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

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

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

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

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

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

Параллельных реализаций в свободном доступе обнаружено не было.

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

Участник:Светлана Лукьяненко/Строгий алгоритм С средних (Hard C-Means, HCM)

2016-10-14T19:29:24Z

Юрий Комаров: /* Описание алгоритма */

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

Авторы описания: [[Участник:Светлана_Лукьяненко|Лукьяненко Светлана]], [[Участник:Юрий_Комаров|Комаров Юрий]].

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

=== Общее описание алгоритма ===
'''Строгий алгоритм C средних''' ('''''Hard C-Means'''''; ''Jang, Sun and Mizutani, 1997'') позволяет распределить большие наборы числовых данных по кластерам в многомерном пространстве<ref>Jan Jantzen «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> Нейский И.М. Классификация и сравнение методов кластеризации.</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>(2n-1)NC</math> арифметических операций сложения и вычитания;
* <math>(3+(n+1)C)N</math> операций умножения.

Ожидая, что предельная точность будет достигнута менее, чем за <math>N</math> итераций (в противном случае применение алгоритма можно считать нецелесообразным), получаем итоговую сложность последовательной реализации алгоритма <math>O(N)</math> (в предположении, что <math>n</math> и <math>C</math> существенно меньше <math>N</math>).

=== Информационный граф ===
[[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>), '''''d1,...,dC''''' — прямое вычисление расстояния до кластерных центров, '''''max''''' — вычисление максимума двух чисел (с сохранением соответствующего максимуму кластерного индекса) и '''''out''''' — вывод полученных данных (индекс кластерного центра, расположенного ближе всего к точке <math>u_i</math>, и соответствующее расстояние).]]

=== Ресурс параллелизма алгоритма ===
Для выполнения одной итерации алгоритма C средних необходимо выполнить параллельно ряд вычислений для каждого из <math>n</math> элементов:

1. Вычисление <math>c</math> расстояний между элементом и кластерными центрами.

2. Выполнение <math>(c - 1)</math> сравнений для определения минимального.

3. Определение значений столбца матрицы принадлежности <math>M</math>, соответствующей элементу.

=== Входные и выходные данные алгоритма ===
'''Входные данные:'''
*<math>\{u_k\}_{k=1}^{n} \subset \mathbb{R}^m</math> — исходный набор векторов;
*<math>c</math> — желаемое количество кластеров (<math>2 \leqslant c \leqslant n</math>);
* ''(опционально)'' <math>\varepsilon_{tr}</math> — пороговая точность работы алгоритма.

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

'''Выходные данные:'''
*<math>M</math> — рядовая матрица из пространства <math>\mathbb{R}^{c \times n}</math>.

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

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

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

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

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

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

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

Параллельных реализаций в свободном доступе обнаружено не было.

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

Участник:Светлана Лукьяненко/Строгий алгоритм С средних (Hard C-Means, HCM)

2016-10-14T19:27:10Z

Юрий Комаров: /* Последовательная сложность алгоритма */

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

Авторы описания: [[Участник:Светлана_Лукьяненко|Лукьяненко Светлана]], [[Участник:Юрий_Комаров|Комаров Юрий]].

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

=== Общее описание алгоритма ===
'''Строгий алгоритм C средних''' ('''''Hard C-Means'''''; ''Jang, Sun and Mizutani, 1997'') позволяет распределить большие наборы числовых данных по кластерам в многомерном пространстве<ref>Jan Jantzen «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> Нейский И.М. Классификация и сравнение методов кластеризации.</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=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>(2n-1)NC</math> арифметических операций сложения и вычитания;
* <math>(3+(n+1)C)N</math> операций умножения.

Ожидая, что предельная точность будет достигнута менее, чем за <math>N</math> итераций (в противном случае применение алгоритма можно считать нецелесообразным), получаем итоговую сложность последовательной реализации алгоритма <math>O(N)</math> (в предположении, что <math>n</math> и <math>C</math> существенно меньше <math>N</math>).

=== Информационный граф ===
[[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>), '''''d1,...,dC''''' — прямое вычисление расстояния до кластерных центров, '''''max''''' — вычисление максимума двух чисел (с сохранением соответствующего максимуму кластерного индекса) и '''''out''''' — вывод полученных данных (индекс кластерного центра, расположенного ближе всего к точке <math>u_i</math>, и соответствующее расстояние).]]

=== Ресурс параллелизма алгоритма ===
Для выполнения одной итерации алгоритма C средних необходимо выполнить параллельно ряд вычислений для каждого из <math>n</math> элементов:

1. Вычисление <math>c</math> расстояний между элементом и кластерными центрами.

2. Выполнение <math>(c - 1)</math> сравнений для определения минимального.

3. Определение значений столбца матрицы принадлежности <math>M</math>, соответствующей элементу.

=== Входные и выходные данные алгоритма ===
'''Входные данные:'''
*<math>\{u_k\}_{k=1}^{n} \subset \mathbb{R}^m</math> — исходный набор векторов;
*<math>c</math> — желаемое количество кластеров (<math>2 \leqslant c \leqslant n</math>);
* ''(опционально)'' <math>\varepsilon_{tr}</math> — пороговая точность работы алгоритма.

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

'''Выходные данные:'''
*<math>M</math> — рядовая матрица из пространства <math>\mathbb{R}^{c \times n}</math>.

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

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

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

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

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

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

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

Параллельных реализаций в свободном доступе обнаружено не было.

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

Участник:Светлана Лукьяненко/Строгий алгоритм С средних (Hard C-Means, HCM)

2016-10-14T19:20:58Z

Юрий Комаров: /* Схема реализации последовательного алгоритма */

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

Авторы описания: [[Участник:Светлана_Лукьяненко|Лукьяненко Светлана]], [[Участник:Юрий_Комаров|Комаров Юрий]].

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

=== Общее описание алгоритма ===
'''Строгий алгоритм C средних''' ('''''Hard C-Means'''''; ''Jang, Sun and Mizutani, 1997'') позволяет распределить большие наборы числовых данных по кластерам в многомерном пространстве<ref>Jan Jantzen «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> Нейский И.М. Классификация и сравнение методов кластеризации.</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=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>2m</math> арифметических операций сложения и вычитания и <math>m</math> операций возведения в квадрат (умножений), получаем, что реализация алгоритма требует выполнения
* <math>2mnC</math> арифметических операций сложения и вычитания;
* <math>(3+(m+1)C)n</math> операций умножения
на каждой итерации цикла.

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

=== Информационный граф ===
[[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>), '''''d1,...,dC''''' — прямое вычисление расстояния до кластерных центров, '''''max''''' — вычисление максимума двух чисел (с сохранением соответствующего максимуму кластерного индекса) и '''''out''''' — вывод полученных данных (индекс кластерного центра, расположенного ближе всего к точке <math>u_i</math>, и соответствующее расстояние).]]

=== Ресурс параллелизма алгоритма ===
Для выполнения одной итерации алгоритма C средних необходимо выполнить параллельно ряд вычислений для каждого из <math>n</math> элементов:

1. Вычисление <math>c</math> расстояний между элементом и кластерными центрами.

2. Выполнение <math>(c - 1)</math> сравнений для определения минимального.

3. Определение значений столбца матрицы принадлежности <math>M</math>, соответствующей элементу.

=== Входные и выходные данные алгоритма ===
'''Входные данные:'''
*<math>\{u_k\}_{k=1}^{n} \subset \mathbb{R}^m</math> — исходный набор векторов;
*<math>c</math> — желаемое количество кластеров (<math>2 \leqslant c \leqslant n</math>);
* ''(опционально)'' <math>\varepsilon_{tr}</math> — пороговая точность работы алгоритма.

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

'''Выходные данные:'''
*<math>M</math> — рядовая матрица из пространства <math>\mathbb{R}^{c \times n}</math>.

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

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

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

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

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

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

Участник:Светлана Лукьяненко/Строгий алгоритм С средних (Hard C-Means, HCM)

2016-10-14T19:20:17Z

Юрий Комаров: /* Макроструктура алгоритма */

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

Авторы описания: [[Участник:Светлана_Лукьяненко|Лукьяненко Светлана]], [[Участник:Юрий_Комаров|Комаров Юрий]].

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

=== Общее описание алгоритма ===
'''Строгий алгоритм C средних''' ('''''Hard C-Means'''''; ''Jang, Sun and Mizutani, 1997'') позволяет распределить большие наборы числовых данных по кластерам в многомерном пространстве<ref>Jan Jantzen «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> Нейский И.М. Классификация и сравнение методов кластеризации.</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=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>2m</math> арифметических операций сложения и вычитания и <math>m</math> операций возведения в квадрат (умножений), получаем, что реализация алгоритма требует выполнения
* <math>2mnC</math> арифметических операций сложения и вычитания;
* <math>(3+(m+1)C)n</math> операций умножения
на каждой итерации цикла.

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

=== Информационный граф ===
[[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>), '''''d1,...,dC''''' — прямое вычисление расстояния до кластерных центров, '''''max''''' — вычисление максимума двух чисел (с сохранением соответствующего максимуму кластерного индекса) и '''''out''''' — вывод полученных данных (индекс кластерного центра, расположенного ближе всего к точке <math>u_i</math>, и соответствующее расстояние).]]

=== Ресурс параллелизма алгоритма ===
Для выполнения одной итерации алгоритма C средних необходимо выполнить параллельно ряд вычислений для каждого из <math>n</math> элементов:

1. Вычисление <math>c</math> расстояний между элементом и кластерными центрами.

2. Выполнение <math>(c - 1)</math> сравнений для определения минимального.

3. Определение значений столбца матрицы принадлежности <math>M</math>, соответствующей элементу.

=== Входные и выходные данные алгоритма ===
'''Входные данные:'''
*<math>\{u_k\}_{k=1}^{n} \subset \mathbb{R}^m</math> — исходный набор векторов;
*<math>c</math> — желаемое количество кластеров (<math>2 \leqslant c \leqslant n</math>);
* ''(опционально)'' <math>\varepsilon_{tr}</math> — пороговая точность работы алгоритма.

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

'''Выходные данные:'''
*<math>M</math> — рядовая матрица из пространства <math>\mathbb{R}^{c \times n}</math>.

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

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

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

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

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

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

Участник:Светлана Лукьяненко/Строгий алгоритм С средних (Hard C-Means, HCM)

2016-10-14T19:19:42Z

Юрий Комаров: /* Входные и выходные данные */

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

Авторы описания: [[Участник:Светлана_Лукьяненко|Лукьяненко Светлана]], [[Участник:Юрий_Комаров|Комаров Юрий]].

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

=== Общее описание алгоритма ===
'''Строгий алгоритм C средних''' ('''''Hard C-Means'''''; ''Jang, Sun and Mizutani, 1997'') позволяет распределить большие наборы числовых данных по кластерам в многомерном пространстве<ref>Jan Jantzen «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> Нейский И.М. Классификация и сравнение методов кластеризации.</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=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>2m</math> арифметических операций сложения и вычитания и <math>m</math> операций возведения в квадрат (умножений), получаем, что реализация алгоритма требует выполнения
* <math>2mnC</math> арифметических операций сложения и вычитания;
* <math>(3+(m+1)C)n</math> операций умножения
на каждой итерации цикла.

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

=== Информационный граф ===
[[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>), '''''d1,...,dC''''' — прямое вычисление расстояния до кластерных центров, '''''max''''' — вычисление максимума двух чисел (с сохранением соответствующего максимуму кластерного индекса) и '''''out''''' — вывод полученных данных (индекс кластерного центра, расположенного ближе всего к точке <math>u_i</math>, и соответствующее расстояние).]]

=== Ресурс параллелизма алгоритма ===
Для выполнения одной итерации алгоритма C средних необходимо выполнить параллельно ряд вычислений для каждого из <math>n</math> элементов:

1. Вычисление <math>c</math> расстояний между элементом и кластерными центрами.

2. Выполнение <math>(c - 1)</math> сравнений для определения минимального.

3. Определение значений столбца матрицы принадлежности <math>M</math>, соответствующей элементу.

=== Входные и выходные данные алгоритма ===
'''Входные данные:'''
*<math>\{u_k\}_{k=1}^{n} \subset \mathbb{R}^m</math> — исходный набор векторов;
*<math>c</math> — желаемое количество кластеров (<math>2 \leqslant c \leqslant n</math>);
* ''(опционально)'' <math>\varepsilon_{tr}</math> — пороговая точность работы алгоритма.

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

'''Выходные данные:'''
*<math>M</math> — рядовая матрица из пространства <math>\mathbb{R}^{c \times n}</math>.

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

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

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

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

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

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

Участник:Светлана Лукьяненко/Строгий алгоритм С средних (Hard C-Means, HCM)

2016-10-14T19:19:05Z

Юрий Комаров: /* Вычислительное ядро алгоритма */

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

Авторы описания: [[Участник:Светлана_Лукьяненко|Лукьяненко Светлана]], [[Участник:Юрий_Комаров|Комаров Юрий]].

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

=== Общее описание алгоритма ===
'''Строгий алгоритм C средних''' ('''''Hard C-Means'''''; ''Jang, Sun and Mizutani, 1997'') позволяет распределить большие наборы числовых данных по кластерам в многомерном пространстве<ref>Jan Jantzen «Neurofuzzy Modelling». Электронное издание.</ref>. Алгоритм является управляемым, так как для работы с ним требуется задание одного параметра — числа кластеров, на которое необходимо разделить данные.
Входными данными для алгоритма являются набор векторов и количество кластеров, также может задаваться пороговое значение величины объектной функции, по достижении которого расчёт прекращается. Выходными данными для алгоритма является рядовая матрица, отображающая принадлежность исходных элементов построенным кластерам, и центры построенных кластеров.

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

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

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

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

==== Входные и выходные данные ====
На вход подаётся набор векторов <math>\{u_k\}_{k=1}^{n}</math> пространства <math>\mathbb{R}^m</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> Нейский И.М. Классификация и сравнение методов кластеризации.</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=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>2m</math> арифметических операций сложения и вычитания и <math>m</math> операций возведения в квадрат (умножений), получаем, что реализация алгоритма требует выполнения
* <math>2mnC</math> арифметических операций сложения и вычитания;
* <math>(3+(m+1)C)n</math> операций умножения
на каждой итерации цикла.

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

=== Информационный граф ===
[[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>), '''''d1,...,dC''''' — прямое вычисление расстояния до кластерных центров, '''''max''''' — вычисление максимума двух чисел (с сохранением соответствующего максимуму кластерного индекса) и '''''out''''' — вывод полученных данных (индекс кластерного центра, расположенного ближе всего к точке <math>u_i</math>, и соответствующее расстояние).]]

=== Ресурс параллелизма алгоритма ===
Для выполнения одной итерации алгоритма C средних необходимо выполнить параллельно ряд вычислений для каждого из <math>n</math> элементов:

1. Вычисление <math>c</math> расстояний между элементом и кластерными центрами.

2. Выполнение <math>(c - 1)</math> сравнений для определения минимального.

3. Определение значений столбца матрицы принадлежности <math>M</math>, соответствующей элементу.

=== Входные и выходные данные алгоритма ===
'''Входные данные:'''
*<math>\{u_k\}_{k=1}^{n} \subset \mathbb{R}^m</math> — исходный набор векторов;
*<math>c</math> — желаемое количество кластеров (<math>2 \leqslant c \leqslant n</math>);
* ''(опционально)'' <math>\varepsilon_{tr}</math> — пороговая точность работы алгоритма.

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

'''Выходные данные:'''
*<math>M</math> — рядовая матрица из пространства <math>\mathbb{R}^{c \times n}</math>.

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

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

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

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

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

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

Участник:Светлана Лукьяненко/Строгий алгоритм С средних (Hard C-Means, HCM)

2016-10-14T19:18:48Z

Юрий Комаров: /* Описание алгоритма */

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

Авторы описания: [[Участник:Светлана_Лукьяненко|Лукьяненко Светлана]], [[Участник:Юрий_Комаров|Комаров Юрий]].

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

=== Общее описание алгоритма ===
'''Строгий алгоритм C средних''' ('''''Hard C-Means'''''; ''Jang, Sun and Mizutani, 1997'') позволяет распределить большие наборы числовых данных по кластерам в многомерном пространстве<ref>Jan Jantzen «Neurofuzzy Modelling». Электронное издание.</ref>. Алгоритм является управляемым, так как для работы с ним требуется задание одного параметра — числа кластеров, на которое необходимо разделить данные.
Входными данными для алгоритма являются набор векторов и количество кластеров, также может задаваться пороговое значение величины объектной функции, по достижении которого расчёт прекращается. Выходными данными для алгоритма является рядовая матрица, отображающая принадлежность исходных элементов построенным кластерам, и центры построенных кластеров.

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

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

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

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

==== Входные и выходные данные ====
На вход подаётся набор векторов <math>\{u_k\}_{k=1}^{n}</math> пространства <math>\mathbb{R}^m</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> Нейский И.М. Классификация и сравнение методов кластеризации.</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=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>2m</math> арифметических операций сложения и вычитания и <math>m</math> операций возведения в квадрат (умножений), получаем, что реализация алгоритма требует выполнения
* <math>2mnC</math> арифметических операций сложения и вычитания;
* <math>(3+(m+1)C)n</math> операций умножения
на каждой итерации цикла.

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

=== Информационный граф ===
[[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>), '''''d1,...,dC''''' — прямое вычисление расстояния до кластерных центров, '''''max''''' — вычисление максимума двух чисел (с сохранением соответствующего максимуму кластерного индекса) и '''''out''''' — вывод полученных данных (индекс кластерного центра, расположенного ближе всего к точке <math>u_i</math>, и соответствующее расстояние).]]

=== Ресурс параллелизма алгоритма ===
Для выполнения одной итерации алгоритма C средних необходимо выполнить параллельно ряд вычислений для каждого из <math>n</math> элементов:

1. Вычисление <math>c</math> расстояний между элементом и кластерными центрами.

2. Выполнение <math>(c - 1)</math> сравнений для определения минимального.

3. Определение значений столбца матрицы принадлежности <math>M</math>, соответствующей элементу.

=== Входные и выходные данные алгоритма ===
'''Входные данные:'''
*<math>\{u_k\}_{k=1}^{n} \subset \mathbb{R}^m</math> — исходный набор векторов;
*<math>c</math> — желаемое количество кластеров (<math>2 \leqslant c \leqslant n</math>);
* ''(опционально)'' <math>\varepsilon_{tr}</math> — пороговая точность работы алгоритма.

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

'''Выходные данные:'''
*<math>M</math> — рядовая матрица из пространства <math>\mathbb{R}^{c \times n}</math>.

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

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

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

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

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

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

Участник:Светлана Лукьяненко/Строгий алгоритм С средних (Hard C-Means, HCM)

2016-10-14T19:16:59Z

Юрий Комаров: /* Описание алгоритма */

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

Авторы описания: [[Участник:Светлана_Лукьяненко|Лукьяненко Светлана]], [[Участник:Юрий_Комаров|Комаров Юрий]].

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

=== Общее описание алгоритма ===
'''Строгий алгоритм C средних''' ('''''Hard C-Means'''''; ''Jang, Sun and Mizutani, 1997'') позволяет распределить большие наборы числовых данных по кластерам в многомерном пространстве<ref>Jan Jantzen «Neurofuzzy Modelling». Электронное издание.</ref>. Алгоритм является управляемым, так как для работы с ним требуется задание одного параметра — числа кластеров, на которое необходимо разделить данные.
Входными данными для алгоритма являются набор векторов и количество кластеров, также может задаваться пороговое значение величины объектной функции, по достижении которого расчёт прекращается. Выходными данными для алгоритма является рядовая матрица, отображающая принадлежность исходных элементов построенным кластерам, и центры построенных кластеров.

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

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

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

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

==== Входные и выходные данные ====
На вход подаётся набор векторов <math>\{u_k\}_{k=1}^{n}</math> пространства <math>\mathbb{R}^m</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> Нейский И.М. Классификация и сравнение методов кластеризации.</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=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>2m</math> арифметических операций сложения и вычитания и <math>m</math> операций возведения в квадрат (умножений), получаем, что реализация алгоритма требует выполнения
* <math>2mnC</math> арифметических операций сложения и вычитания;
* <math>(3+(m+1)C)n</math> операций умножения
на каждой итерации цикла.

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

=== Информационный граф ===
[[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>), '''''d1,...,dC''''' — прямое вычисление расстояния до кластерных центров, '''''max''''' — вычисление максимума двух чисел (с сохранением соответствующего максимуму кластерного индекса) и '''''out''''' — вывод полученных данных (индекс кластерного центра, расположенного ближе всего к точке <math>u_i</math>, и соответствующее расстояние).]]

=== Ресурс параллелизма алгоритма ===
Для выполнения одной итерации алгоритма C средних необходимо выполнить параллельно ряд вычислений для каждого из <math>n</math> элементов:

1. Вычисление <math>c</math> расстояний между элементом и кластерными центрами.

2. Выполнение <math>(c - 1)</math> сравнений для определения минимального.

3. Определение значений столбца матрицы принадлежности <math>M</math>, соответствующей элементу.

=== Входные и выходные данные алгоритма ===
'''Входные данные:'''
*<math>\{u_k\}_{k=1}^{n} \subset \mathbb{R}^m</math> — исходный набор векторов;
*<math>c</math> — желаемое количество кластеров (<math>2 \leqslant c \leqslant n</math>);
* ''(опционально)'' <math>\varepsilon_{tr}</math> — пороговая точность работы алгоритма.

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

'''Выходные данные:'''
*<math>M</math> — рядовая матрица из пространства <math>\mathbb{R}^{c \times n}</math>.

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

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

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

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

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

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

Участник:Светлана Лукьяненко/Строгий алгоритм С средних (Hard C-Means, HCM)

2016-10-14T19:15:10Z

Юрий Комаров: /* Описание алгоритма */

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

Авторы описания: [[Участник:Светлана_Лукьяненко|Лукьяненко Светлана]], [[Участник:Юрий_Комаров|Комаров Юрий]].

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

=== Общее описание алгоритма ===
'''Строгий алгоритм C средних''' ('''''Hard C-Means'''''; ''Jang, Sun and Mizutani, 1997'') позволяет распределить большие наборы числовых данных по кластерам в многомерном пространстве<ref>Jan Jantzen «Neurofuzzy Modelling». Электронное издание.</ref>. Алгоритм является управляемым, так как для работы с ним требуется задание одного параметра — числа кластеров, на которое необходимо разделить данные.
Входными данными для алгоритма являются набор векторов и количество кластеров, также может задаваться пороговое значение величины объектной функции, по достижении которого расчёт прекращается. Выходными данными для алгоритма является рядовая матрица, отображающая принадлежность исходных элементов построенным кластерам, и центры построенных кластеров.

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

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

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

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

==== Входные и выходные данные ====
На вход подаётся набор векторов <math>\{u_k\}_{k=1}^{n}</math> пространства <math>\mathbb{R}^m</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> Нейский И.М. Классификация и сравнение методов кластеризации.</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=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>2m</math> арифметических операций сложения и вычитания и <math>m</math> операций возведения в квадрат (умножений), получаем, что реализация алгоритма требует выполнения
* <math>2mnC</math> арифметических операций сложения и вычитания;
* <math>(3+(m+1)C)n</math> операций умножения
на каждой итерации цикла.

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

=== Информационный граф ===
[[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>), '''''d1,...,dC''''' — прямое вычисление расстояния до кластерных центров, '''''max''''' — вычисление максимума двух чисел (с сохранением соответствующего максимуму кластерного индекса) и '''''out''''' — вывод полученных данных (индекс кластерного центра, расположенного ближе всего к точке <math>u_i</math>, и соответствующее расстояние).]]

=== Ресурс параллелизма алгоритма ===
Для выполнения одной итерации алгоритма C средних необходимо выполнить параллельно ряд вычислений для каждого из <math>n</math> элементов:

1. Вычисление <math>c</math> расстояний между элементом и кластерными центрами.

2. Выполнение <math>(c - 1)</math> сравнений для определения минимального.

3. Определение значений столбца матрицы принадлежности <math>M</math>, соответствующей элементу.

=== Входные и выходные данные алгоритма ===
'''Входные данные:'''
*<math>\{u_k\}_{k=1}^{n} \subset \mathbb{R}^m</math> — исходный набор векторов;
*<math>c</math> — желаемое количество кластеров (<math>2 \leqslant c \leqslant n</math>);
* ''(опционально)'' <math>\varepsilon_{tr}</math> — пороговая точность работы алгоритма.

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

'''Выходные данные:'''
*<math>M</math> — рядовая матрица из пространства <math>\mathbb{R}^{c \times n}</math>.

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

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

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

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

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

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

Участник:Светлана Лукьяненко/Строгий алгоритм С средних (Hard C-Means, HCM)

2016-10-14T19:14:50Z

Юрий Комаров: /* Входные и выходные данные */

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

Авторы описания: [[Участник:Светлана_Лукьяненко|Лукьяненко Светлана]], [[Участник:Юрий_Комаров|Комаров Юрий]].

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

=== Общее описание алгоритма ===
'''Строгий алгоритм C средних''' ('''''Hard C-Means'''''; ''Jang, Sun and Mizutani, 1997'') позволяет распределить большие наборы числовых данных по кластерам в многомерном пространстве<ref>Jan Jantzen «Neurofuzzy Modelling». Электронное издание.</ref>. Алгоритм является управляемым, так как для работы с ним требуется задание одного параметра — числа кластеров, на которое необходимо разделить данные.
Входными данными для алгоритма являются набор векторов и количество кластеров, также может задаваться пороговое значение величины объектной функции, по достижении которого расчёт прекращается. Выходными данными для алгоритма является рядовая матрица, отображающая принадлежность исходных элементов построенным кластерам, и центры построенных кластеров.

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

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

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

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

==== Входные и выходные данные ====
На вход подаётся набор векторов <math>\{u_k\}_{k=1}^{n}</math> пространства <math>\mathbb{R}^m</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> Нейский И.М. Классификация и сравнение методов кластеризации.</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=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>2m</math> арифметических операций сложения и вычитания и <math>m</math> операций возведения в квадрат (умножений), получаем, что реализация алгоритма требует выполнения
* <math>2mnC</math> арифметических операций сложения и вычитания;
* <math>(3+(m+1)C)n</math> операций умножения
на каждой итерации цикла.

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

=== Информационный граф ===
[[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>), '''''d1,...,dC''''' — прямое вычисление расстояния до кластерных центров, '''''max''''' — вычисление максимума двух чисел (с сохранением соответствующего максимуму кластерного индекса) и '''''out''''' — вывод полученных данных (индекс кластерного центра, расположенного ближе всего к точке <math>u_i</math>, и соответствующее расстояние).]]

=== Ресурс параллелизма алгоритма ===
Для выполнения одной итерации алгоритма C средних необходимо выполнить параллельно ряд вычислений для каждого из <math>n</math> элементов:

1. Вычисление <math>c</math> расстояний между элементом и кластерными центрами.

2. Выполнение <math>(c - 1)</math> сравнений для определения минимального.

3. Определение значений столбца матрицы принадлежности <math>M</math>, соответствующей элементу.

=== Входные и выходные данные алгоритма ===
'''Входные данные:'''
*<math>\{u_k\}_{k=1}^{n} \subset \mathbb{R}^m</math> — исходный набор векторов;
*<math>c</math> — желаемое количество кластеров (<math>2 \leqslant c \leqslant n</math>);
* ''(опционально)'' <math>\varepsilon_{tr}</math> — пороговая точность работы алгоритма.

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

'''Выходные данные:'''
*<math>M</math> — рядовая матрица из пространства <math>\mathbb{R}^{c \times n}</math>.

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

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

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

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

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

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