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

Обсуждение участника:Каледа Александр

2016-12-18T20:59:08Z

Каледа Александр:

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

* У вас в сложности фигурирует количество итераций. В литературе есть какие-то оценки требуемого количества итераций исходя из входных параметров? Если есть, то хорошо бы указать. [[Участник:Chalker|Chalker]] ([[Обсуждение участника:Chalker|обсуждение]]) 18:23, 18 декабря 2016 (MSK)
** Нет, оценок нет.

* 1.8 — высота не равна O(1) на вашем графе, она зависит в том числе от n. [[Участник:Chalker|Chalker]] ([[Обсуждение участника:Chalker|обсуждение]]) 23:43, 17 декабря 2016 (MSK)
** Исправлено.

* 1.6 — Не совсем понятно, как сложность алгоритма получилась меньше объёма входных данных. Она не зависит от m? [[Участник:Chalker|Chalker]] ([[Обсуждение участника:Chalker|обсуждение]]) 18:48, 5 декабря 2016 (MSK)
** В пункте 1.6 написано, что мы исходим из следующего предположения - размерность m и количество кластерных центров C существенно меньше n.
*** Это всё равно вам не даёт сложности O(N). Она зависит от m и C. [[Участник:Chalker|Chalker]] ([[Обсуждение участника:Chalker|обсуждение]]) 23:43, 17 декабря 2016 (MSK)
**** Исправлено.

* 2.4 — Написано, что исследование проводилось на системе с двумя процессорами E5-2697 v2. У них по 12 физических ядер [https://ark.intel.com/ru/products/75283/Intel-Xeon-Processor-E5-2697-v2-30M-Cache-2_70-GHz]. Как это согласуется с «number of processors», доходящим до 48 на графике? Всё, что выше 24 — определённо Hyper Threading. [[Участник:Chalker|Chalker]] ([[Обсуждение участника:Chalker|обсуждение]]) 18:16, 5 декабря 2016 (MSK)
** Да, Вы правы, у нас был включен ht.
*** Стоит указать количество реальных ядер и количество потоков в тексте. В графиках у вас всё ещё подписано «number of processors», и он всё ещё доходит до 48. [[Участник:Chalker|Chalker]] ([[Обсуждение участника:Chalker|обсуждение]]) 23:43, 17 декабря 2016 (MSK)
**** Исправлено.
----------------------
* Не указан вклад каждого автора [[Участник:Coctic|Coctic]] ([[Обсуждение участника:Coctic|обсуждение]]) 11:08, 25 октября 2016 (MSK)
** Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 12:42, 2 ноября 2016 (MSK)
* Стоит добавить ссылку на оригинальную публикацию, в которой был впервые предложен алгоритм. [[Участник:Coctic|Coctic]] ([[Обсуждение участника:Coctic|обсуждение]]) 11:08, 25 октября 2016 (MSK)
** Не исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 12:42, 2 ноября 2016 (MSK)
* Значительная часть п. 1.2 совпадает с тем же пунктом из [[Строгий алгоритм С средних (Hard C-Means, HCM)]]
** Замечание снимается [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 12:42, 2 ноября 2016 (MSK)
* Пункты раздела 2 не соответствуют шаблону. П. 2.1 должен быть 2.4, п. 2.2 должен быть 2.7, остальные пункты пропущены [[Участник:Coctic|Coctic]] ([[Обсуждение участника:Coctic|обсуждение]]) 11:08, 25 октября 2016 (MSK)
** Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 12:42, 2 ноября 2016 (MSK)
* В списке литературы отсутствуют выходные данные публикаций, кроме названия и автора. По приведенным данным определить конкретную публикацию не представляется возможным. [[Участник:Coctic|Coctic]] ([[Обсуждение участника:Coctic|обсуждение]]) 11:08, 25 октября 2016 (MSK)
** Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 12:42, 2 ноября 2016 (MSK)
* Список литературы совпадает со списком из [[Строгий алгоритм С средних (Hard C-Means, HCM)]] [[Участник:Coctic|Coctic]] ([[Обсуждение участника:Coctic|обсуждение]]) 11:08, 25 октября 2016 (MSK)
** Замечание снимается [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 12:42, 2 ноября 2016 (MSK)

------------
* Стоит добавить ссылку на оригинальную публикацию, в которой был впервые предложен алгоритм [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 12:42, 2 ноября 2016 (MSK)
** Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 13:16, 23 ноября 2016 (MSK)
* п. 2.4.1 пустой. [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 10:35, 17 ноября 2016 (MSK)
** Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 13:16, 23 ноября 2016 (MSK)
* п. 2.4.2. Отсутствует ссылка на текст исследуемой программы и аппаратную платформу, на которой проводилось тестирование. [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 10:35, 17 ноября 2016 (MSK)
** Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 13:16, 23 ноября 2016 (MSK)
* Рис. 3. В подписи к рисунку не указано, график зависимости эффективности какого типа приведен. [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 10:35, 17 ноября 2016 (MSK)
** Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 13:16, 23 ноября 2016 (MSK)

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

2016-12-18T20:58:24Z

Каледа Александр:

{{Assignment|{{REVISIONUSER}}}}

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

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

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

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

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

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

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

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

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

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

Алгоритм:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Число итераций алгоритма оценим как <math>O(nC)</math>. Исходя из того, что сложность вычислительного блока <math>M</math> равна <math>log_2(C)</math>, а сложность расчета функционала <math>J</math> составляет <math>log_2(n)</math>, имеем, что высота итерации составляет <math>log_2(nC)</math>. Таким образом, высота [[глоссарий#Ярусно-параллельная форма графа алгоритма|ЯПФ]] оценивается как <math>O(nClog_2(nC))</math>.

Ширина [[глоссарий#Ярусно-параллельная форма графа алгоритма|ЯПФ]] равна <math>n</math>.

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

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

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

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

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

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

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

Недостатки:

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

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

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

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

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

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

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

Исследование проводилось на 1U сервере со '''следующими характеристиками''':
* 2 x Intel® Xeon® Processor E5-2697 v2, всего 24 физических ядра (48 логических ядра при включенном Hyper-Threading);
* 128GB RAM;

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

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

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

* число логических ядер [1 : 48] с шагом 2;
* размерность пространства [3 : 50] c шагом 3;
* число векторов 100 000 000;
* число кластерных центров 30;

В результате проведённых экспериментов был получен следующий диапазон [[Глоссарий#Эффективность реализации|эффективности реализации]] алгоритма (отношение реальной производительности программы к пиковым показателям работы вычислительной системы):

* минимальная эффективность реализации 0.014;
* максимальная эффективность реализации 0.9;

На следующих рисунках приведены графики [[Глоссарий#Производительность|производительности]] и эффективности выбранной реализации HCM в зависимости от изменяемых параметров запуска.

[[file:1new.png|thumb|center|700px|Рисунок 2. Параллельная реализация алгоритма. Изменение производительности в зависимости от числа процессоров и размерности векторов.]]
[[file:2new.png|thumb|center|700px|Рисунок 3. Параллельная реализация алгоритма. Изменение эффективности в зависимости от числа процессоров и размерности векторов.]]

==== Реализация на языке C++ ====
[http://pastebin.com/31UkHgcW Исследованная параллельная реализация на языке C++]

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

=== Существующие реализации алгоритма ===
* [http://projects.jasmeet.me/2013/03/HardCMeans.html Последовательная реализация алгоритма на MatLab]
* [https://github.com/artpar/Hard-Clustering-implementation Последовательная реализация алгоритма на С++]

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

Обсуждение участника:Каледа Александр

2016-12-18T20:04:57Z

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

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

* У вас в сложности фигурирует количество итераций. В литературе есть какие-то оценки требуемого количества итераций исходя из входных параметров? Если есть, то хорошо бы указать. [[Участник:Chalker|Chalker]] ([[Обсуждение участника:Chalker|обсуждение]]) 18:23, 18 декабря 2016 (MSK)
** Нет, оценок нет.

* 1.8 — высота не равна O(1) на вашем графе, она зависит в том числе от n. [[Участник:Chalker|Chalker]] ([[Обсуждение участника:Chalker|обсуждение]]) 23:43, 17 декабря 2016 (MSK)

* 1.6 — Не совсем понятно, как сложность алгоритма получилась меньше объёма входных данных. Она не зависит от m? [[Участник:Chalker|Chalker]] ([[Обсуждение участника:Chalker|обсуждение]]) 18:48, 5 декабря 2016 (MSK)
** В пункте 1.6 написано, что мы исходим из следующего предположения - размерность m и количество кластерных центров C существенно меньше n.
*** Это всё равно вам не даёт сложности O(N). Она зависит от m и C. [[Участник:Chalker|Chalker]] ([[Обсуждение участника:Chalker|обсуждение]]) 23:43, 17 декабря 2016 (MSK)
**** Исправлено.

* 2.4 — Написано, что исследование проводилось на системе с двумя процессорами E5-2697 v2. У них по 12 физических ядер [https://ark.intel.com/ru/products/75283/Intel-Xeon-Processor-E5-2697-v2-30M-Cache-2_70-GHz]. Как это согласуется с «number of processors», доходящим до 48 на графике? Всё, что выше 24 — определённо Hyper Threading. [[Участник:Chalker|Chalker]] ([[Обсуждение участника:Chalker|обсуждение]]) 18:16, 5 декабря 2016 (MSK)
** Да, Вы правы, у нас был включен ht.
*** Стоит указать количество реальных ядер и количество потоков в тексте. В графиках у вас всё ещё подписано «number of processors», и он всё ещё доходит до 48. [[Участник:Chalker|Chalker]] ([[Обсуждение участника:Chalker|обсуждение]]) 23:43, 17 декабря 2016 (MSK)
**** Исправлено.
----------------------
* Не указан вклад каждого автора [[Участник:Coctic|Coctic]] ([[Обсуждение участника:Coctic|обсуждение]]) 11:08, 25 октября 2016 (MSK)
** Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 12:42, 2 ноября 2016 (MSK)
* Стоит добавить ссылку на оригинальную публикацию, в которой был впервые предложен алгоритм. [[Участник:Coctic|Coctic]] ([[Обсуждение участника:Coctic|обсуждение]]) 11:08, 25 октября 2016 (MSK)
** Не исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 12:42, 2 ноября 2016 (MSK)
* Значительная часть п. 1.2 совпадает с тем же пунктом из [[Строгий алгоритм С средних (Hard C-Means, HCM)]]
** Замечание снимается [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 12:42, 2 ноября 2016 (MSK)
* Пункты раздела 2 не соответствуют шаблону. П. 2.1 должен быть 2.4, п. 2.2 должен быть 2.7, остальные пункты пропущены [[Участник:Coctic|Coctic]] ([[Обсуждение участника:Coctic|обсуждение]]) 11:08, 25 октября 2016 (MSK)
** Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 12:42, 2 ноября 2016 (MSK)
* В списке литературы отсутствуют выходные данные публикаций, кроме названия и автора. По приведенным данным определить конкретную публикацию не представляется возможным. [[Участник:Coctic|Coctic]] ([[Обсуждение участника:Coctic|обсуждение]]) 11:08, 25 октября 2016 (MSK)
** Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 12:42, 2 ноября 2016 (MSK)
* Список литературы совпадает со списком из [[Строгий алгоритм С средних (Hard C-Means, HCM)]] [[Участник:Coctic|Coctic]] ([[Обсуждение участника:Coctic|обсуждение]]) 11:08, 25 октября 2016 (MSK)
** Замечание снимается [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 12:42, 2 ноября 2016 (MSK)

------------
* Стоит добавить ссылку на оригинальную публикацию, в которой был впервые предложен алгоритм [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 12:42, 2 ноября 2016 (MSK)
** Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 13:16, 23 ноября 2016 (MSK)
* п. 2.4.1 пустой. [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 10:35, 17 ноября 2016 (MSK)
** Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 13:16, 23 ноября 2016 (MSK)
* п. 2.4.2. Отсутствует ссылка на текст исследуемой программы и аппаратную платформу, на которой проводилось тестирование. [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 10:35, 17 ноября 2016 (MSK)
** Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 13:16, 23 ноября 2016 (MSK)
* Рис. 3. В подписи к рисунку не указано, график зависимости эффективности какого типа приведен. [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 10:35, 17 ноября 2016 (MSK)
** Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 13:16, 23 ноября 2016 (MSK)

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

2016-12-18T19:43:37Z

Каледа Александр: /* Информационный граф */

{{Assignment|{{REVISIONUSER}}}}

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

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

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

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

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

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

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

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

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

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

Алгоритм:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Недостатки:

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

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

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

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

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

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

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

Исследование проводилось на 1U сервере со '''следующими характеристиками''':
* 2 x Intel® Xeon® Processor E5-2697 v2, всего 24 физических ядра (48 логических ядра при включенном Hyper-Threading);
* 128GB RAM;

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

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

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

* число логических ядер [1 : 48] с шагом 2;
* размерность пространства [3 : 50] c шагом 3;
* число векторов 100 000 000;
* число кластерных центров 30;

В результате проведённых экспериментов был получен следующий диапазон [[Глоссарий#Эффективность реализации|эффективности реализации]] алгоритма (отношение реальной производительности программы к пиковым показателям работы вычислительной системы):

* минимальная эффективность реализации 0.014;
* максимальная эффективность реализации 0.9;

На следующих рисунках приведены графики [[Глоссарий#Производительность|производительности]] и эффективности выбранной реализации HCM в зависимости от изменяемых параметров запуска.

[[file:1new.png|thumb|center|700px|Рисунок 2. Параллельная реализация алгоритма. Изменение производительности в зависимости от числа процессоров и размерности векторов.]]
[[file:2new.png|thumb|center|700px|Рисунок 3. Параллельная реализация алгоритма. Изменение эффективности в зависимости от числа процессоров и размерности векторов.]]

==== Реализация на языке C++ ====
[http://pastebin.com/31UkHgcW Исследованная параллельная реализация на языке C++]

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

=== Существующие реализации алгоритма ===
* [http://projects.jasmeet.me/2013/03/HardCMeans.html Последовательная реализация алгоритма на MatLab]
* [https://github.com/artpar/Hard-Clustering-implementation Последовательная реализация алгоритма на С++]

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

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

2016-12-18T18:39:18Z

Каледа Александр:

{{Assignment|{{REVISIONUSER}}}}

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

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

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

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

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

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

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

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

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

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

Алгоритм:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Недостатки:

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

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

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

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

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

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

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

Исследование проводилось на 1U сервере со '''следующими характеристиками''':
* 2 x Intel® Xeon® Processor E5-2697 v2, всего 24 физических ядра (48 логических ядра при включенном Hyper-Threading);
* 128GB RAM;

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

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

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

* число логических ядер [1 : 48] с шагом 2;
* размерность пространства [3 : 50] c шагом 3;
* число векторов 100 000 000;
* число кластерных центров 30;

В результате проведённых экспериментов был получен следующий диапазон [[Глоссарий#Эффективность реализации|эффективности реализации]] алгоритма (отношение реальной производительности программы к пиковым показателям работы вычислительной системы):

* минимальная эффективность реализации 0.014;
* максимальная эффективность реализации 0.9;

На следующих рисунках приведены графики [[Глоссарий#Производительность|производительности]] и эффективности выбранной реализации HCM в зависимости от изменяемых параметров запуска.

[[file:1new.png|thumb|center|700px|Рисунок 2. Параллельная реализация алгоритма. Изменение производительности в зависимости от числа процессоров и размерности векторов.]]
[[file:2new.png|thumb|center|700px|Рисунок 3. Параллельная реализация алгоритма. Изменение эффективности в зависимости от числа процессоров и размерности векторов.]]

==== Реализация на языке C++ ====
[http://pastebin.com/31UkHgcW Исследованная параллельная реализация на языке C++]

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

=== Существующие реализации алгоритма ===
* [http://projects.jasmeet.me/2013/03/HardCMeans.html Последовательная реализация алгоритма на MatLab]
* [https://github.com/artpar/Hard-Clustering-implementation Последовательная реализация алгоритма на С++]

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

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

2016-12-18T18:24:51Z

Каледа Александр:

{{Assignment|{{REVISIONUSER}}}}

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

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

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

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

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

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

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

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

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

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

Алгоритм:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Недостатки:

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

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

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

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

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

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

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

Исследование проводилось на 1U сервере со '''следующими характеристиками''':
* 2 x Intel® Xeon® Processor E5-2697 v2, всего 24 физических ядра (48 логических ядра при включенном Hyper-Threading);
* 128GB RAM;

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

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

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

* число логических ядер [1 : 48] с шагом 2;
* размерность пространства [3 : 50] c шагом 3;
* число векторов 100 000 000;
* число кластерных центров 30;

В результате проведённых экспериментов был получен следующий диапазон [[Глоссарий#Эффективность реализации|эффективности реализации]] алгоритма (отношение реальной производительности программы к пиковым показателям работы вычислительной системы):

* минимальная эффективность реализации 0.014;
* максимальная эффективность реализации 0.9;

На следующих рисунках приведены графики [[Глоссарий#Производительность|производительности]] и эффективности выбранной реализации HCM в зависимости от изменяемых параметров запуска.

[[file:GFLOPS_AA.png|thumb|center|700px|Рисунок 2. Параллельная реализация алгоритма. Изменение производительности в зависимости от числа процессоров и размерности векторов.]]
[[file:EFFICIENCY.png|thumb|center|700px|Рисунок 3. Параллельная реализация алгоритма. Изменение эффективности в зависимости от числа процессоров и размерности векторов.]]

==== Реализация на языке C++ ====
[http://pastebin.com/31UkHgcW Исследованная параллельная реализация на языке C++]

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

=== Существующие реализации алгоритма ===
* [http://projects.jasmeet.me/2013/03/HardCMeans.html Последовательная реализация алгоритма на MatLab]
* [https://github.com/artpar/Hard-Clustering-implementation Последовательная реализация алгоритма на С++]

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

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

2016-12-18T18:08:28Z

Каледа Александр:

{{Assignment|{{REVISIONUSER}}}}

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

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

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

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

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

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

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

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

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

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

Алгоритм:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Недостатки:

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

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

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

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

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

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

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

Исследование проводилось на 1U сервере со '''следующими характеристиками''':
* 2 x Intel® Xeon® Processor E5-2697 v2, всего 24 физических ядра (48 логических ядра при включенном Hyper-Threading);
* 128GB RAM;

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

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

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

* число логических ядер [1 : 48] с шагом 2;
* размерность пространства [3 : 50] c шагом 3;
* число векторов 100 000 000;
* число кластерных центров 30;

В результате проведённых экспериментов был получен следующий диапазон [[Глоссарий#Эффективность реализации|эффективности реализации]] алгоритма (отношение реальной производительности программы к пиковым показателям работы вычислительной системы):

* минимальная эффективность реализации 0.014;
* максимальная эффективность реализации 0.9;

На следующих рисунках приведены графики [[Глоссарий#Производительность|производительности]] и эффективности выбранной реализации HCM в зависимости от изменяемых параметров запуска.

[[file:GFLOPS_AA_new.png|thumb|center|700px|Рисунок 2. Параллельная реализация алгоритма. Изменение производительности в зависимости от числа процессоров и размерности векторов.]]
[[file:EFFICIENCY_new.png|thumb|center|700px|Рисунок 3. Параллельная реализация алгоритма. Изменение эффективности в зависимости от числа процессоров и размерности векторов.]]

==== Реализация на языке C++ ====
[http://pastebin.com/31UkHgcW Исследованная параллельная реализация на языке C++]

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

=== Существующие реализации алгоритма ===
* [http://projects.jasmeet.me/2013/03/HardCMeans.html Последовательная реализация алгоритма на MatLab]
* [https://github.com/artpar/Hard-Clustering-implementation Последовательная реализация алгоритма на С++]

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

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

2016-12-18T18:00:45Z

Каледа Александр:

{{Assignment|{{REVISIONUSER}}}}

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

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

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

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

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

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

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

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

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

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

Алгоритм:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Недостатки:

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

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

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

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

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

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

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

Исследование проводилось на 1U сервере со '''следующими характеристиками''':
* 2 x Intel® Xeon® Processor E5-2697 v2, всего 24 физических ядра (48 логических ядра при включенном Hyper-Thereading);
* 128GB RAM;

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

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

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

* число логических ядер [1 : 48] с шагом 1;
* размерность пространства [3 : 50] c шагом 3;
* число векторов 100 000 000;
* число кластерных центров 30;

В результате проведённых экспериментов был получен следующий диапазон [[Глоссарий#Эффективность реализации|эффективности реализации]] алгоритма (отношение реальной производительности программы к пиковым показателям работы вычислительной системы):

* минимальная эффективность реализации 0.014;
* максимальная эффективность реализации 0.9;

На следующих рисунках приведены графики [[Глоссарий#Производительность|производительности]] и эффективности выбранной реализации HCM в зависимости от изменяемых параметров запуска.

[[file:GFLOPS_AA.png|thumb|center|700px|Рисунок 2. Параллельная реализация алгоритма. Изменение производительности в зависимости от числа процессоров и размерности векторов.]]
[[file:EFFICIENCY.png|thumb|center|700px|Рисунок 3. Параллельная реализация алгоритма. Изменение эффективности в зависимости от числа процессоров и размерности векторов.]]

==== Реализация на языке C++ ====
[http://pastebin.com/31UkHgcW Исследованная параллельная реализация на языке C++]

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

=== Существующие реализации алгоритма ===
* [http://projects.jasmeet.me/2013/03/HardCMeans.html Последовательная реализация алгоритма на MatLab]
* [https://github.com/artpar/Hard-Clustering-implementation Последовательная реализация алгоритма на С++]

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

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

2016-12-18T17:59:15Z

Каледа Александр:

{{Assignment|{{REVISIONUSER}}}}

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

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

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

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

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

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

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

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

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

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

Алгоритм:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Недостатки:

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

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

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

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

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

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

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

Исследование проводилось на 1U сервере со '''следующими характеристиками''':
* 2 x Intel® Xeon® Processor E5-2697 v2, всего 24 физических ядра (48 логических ядра при включенном Hyper-Thereading);
* 128GB RAM;

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

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

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

* число логических ядер [1 : 48] с шагом 1;
* размерность пространства [3 : 50] c шагом 3;
* число векторов 100 000 000;
* число кластерных центров 30;

В результате проведённых экспериментов был получен следующий диапазон [[Глоссарий#Эффективность реализации|эффективности реализации]] алгоритма (отношение реальной производительности программы к пиковым показателям работы вычислительной системы):

* минимальная эффективность реализации 0.014;
* максимальная эффективность реализации 0.9;

На следующих рисунках приведены графики [[Глоссарий#Производительность|производительности]] и эффективности выбранной реализации HCM в зависимости от изменяемых параметров запуска.

[[file:GFLOPS_AA.png|thumb|center|700px|Рисунок 2. Параллельная реализация алгоритма. Изменение производительности в зависимости от числа процессоров и размерности векторов.]]
[[file:EFFICIENCY.png|thumb|center|700px|Рисунок 3. Параллельная реализация алгоритма. Изменение эффективности в зависимости от числа процессоров и размерности векторов.]]

==== Реализация на языке C++ ====
[http://pastebin.com/31UkHgcW Исследованная параллельная реализация на языке C++]

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

=== Существующие реализации алгоритма ===
* [http://projects.jasmeet.me/2013/03/HardCMeans.html Последовательная реализация алгоритма на MatLab]
* [https://github.com/artpar/Hard-Clustering-implementation Последовательная реализация алгоритма на С++]

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

Обсуждение участника:Каледа Александр

2016-12-08T13:46:20Z

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

= Статья [[Участник:Каледа Александр/Строгий алгоритм С средних (Hard C-Means)]] =
* 1.6 — Не совсем понятно, как сложность алгоритма получилась меньше объёма входных данных. Она не зависит от m? [[Участник:Chalker|Chalker]] ([[Обсуждение участника:Chalker|обсуждение]]) 18:48, 5 декабря 2016 (MSK)
** В пункте 1.6 написано, что мы исходим из следующего предположения - размерность m и количество кластерных центров C существенно меньше n.

* 2.4 — Написано, что исследование проводилось на системе с двумя процессорами E5-2697 v2. У них по 12 физических ядер [https://ark.intel.com/ru/products/75283/Intel-Xeon-Processor-E5-2697-v2-30M-Cache-2_70-GHz]. Как это согласуется с «number of processors», доходящим до 48 на графике? Всё, что выше 24 — определённо Hyper Threading. [[Участник:Chalker|Chalker]] ([[Обсуждение участника:Chalker|обсуждение]]) 18:16, 5 декабря 2016 (MSK)
** Да, Вы правы, у нас был включен ht.

----------------------
* Не указан вклад каждого автора [[Участник:Coctic|Coctic]] ([[Обсуждение участника:Coctic|обсуждение]]) 11:08, 25 октября 2016 (MSK)
** Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 12:42, 2 ноября 2016 (MSK)
* Стоит добавить ссылку на оригинальную публикацию, в которой был впервые предложен алгоритм. [[Участник:Coctic|Coctic]] ([[Обсуждение участника:Coctic|обсуждение]]) 11:08, 25 октября 2016 (MSK)
** Не исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 12:42, 2 ноября 2016 (MSK)
* Значительная часть п. 1.2 совпадает с тем же пунктом из [[Строгий алгоритм С средних (Hard C-Means, HCM)]]
** Замечание снимается [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 12:42, 2 ноября 2016 (MSK)
* Пункты раздела 2 не соответствуют шаблону. П. 2.1 должен быть 2.4, п. 2.2 должен быть 2.7, остальные пункты пропущены [[Участник:Coctic|Coctic]] ([[Обсуждение участника:Coctic|обсуждение]]) 11:08, 25 октября 2016 (MSK)
** Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 12:42, 2 ноября 2016 (MSK)
* В списке литературы отсутствуют выходные данные публикаций, кроме названия и автора. По приведенным данным определить конкретную публикацию не представляется возможным. [[Участник:Coctic|Coctic]] ([[Обсуждение участника:Coctic|обсуждение]]) 11:08, 25 октября 2016 (MSK)
** Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 12:42, 2 ноября 2016 (MSK)
* Список литературы совпадает со списком из [[Строгий алгоритм С средних (Hard C-Means, HCM)]] [[Участник:Coctic|Coctic]] ([[Обсуждение участника:Coctic|обсуждение]]) 11:08, 25 октября 2016 (MSK)
** Замечание снимается [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 12:42, 2 ноября 2016 (MSK)

------------
* Стоит добавить ссылку на оригинальную публикацию, в которой был впервые предложен алгоритм [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 12:42, 2 ноября 2016 (MSK)
** Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 13:16, 23 ноября 2016 (MSK)
* п. 2.4.1 пустой. [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 10:35, 17 ноября 2016 (MSK)
** Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 13:16, 23 ноября 2016 (MSK)
* п. 2.4.2. Отсутствует ссылка на текст исследуемой программы и аппаратную платформу, на которой проводилось тестирование. [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 10:35, 17 ноября 2016 (MSK)
** Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 13:16, 23 ноября 2016 (MSK)
* Рис. 3. В подписи к рисунку не указано, график зависимости эффективности какого типа приведен. [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 10:35, 17 ноября 2016 (MSK)
** Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 13:16, 23 ноября 2016 (MSK)

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

2016-11-22T20:24:33Z

Каледа Александр:

{{Assignment}}

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

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

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

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

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

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

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

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

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

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

Алгоритм:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Недостатки:

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

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

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

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

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

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

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

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

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

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

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

* число процессоров [1 : 48] с шагом 1;
* размерность пространства [3 : 50] c шагом 3;
* число векторов 100 000 000;
* число кластерных центров 30;

В результате проведённых экспериментов был получен следующий диапазон [[Глоссарий#Эффективность реализации|эффективности реализации]] алгоритма (отношение реальной производительности программы к пиковым показателям работы вычислительной системы):

* минимальная эффективность реализации 0.014;
* максимальная эффективность реализации 0.9;

На следующих рисунках приведены графики [[Глоссарий#Производительность|производительности]] и эффективности выбранной реализации HCM в зависимости от изменяемых параметров запуска.

[[file:GFLOPS_AA.png|thumb|center|700px|Рисунок 2. Параллельная реализация алгоритма. Изменение производительности в зависимости от числа процессоров и размерности векторов.]]
[[file:EFFICIENCY.png|thumb|center|700px|Рисунок 3. Параллельная реализация алгоритма. Изменение эффективности в зависимости от числа процессоров и размерности векторов.]]

==== Реализация на языке C++ ====
[http://pastebin.com/31UkHgcW Исследованная параллельная реализация на языке C++]

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

=== Существующие реализации алгоритма ===
* [http://projects.jasmeet.me/2013/03/HardCMeans.html Последовательная реализация алгоритма на MatLab]
* [https://github.com/artpar/Hard-Clustering-implementation Последовательная реализация алгоритма на С++]

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

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

2016-11-22T20:23:18Z

Каледа Александр: /* Масштабируемость реализации алгоритма */

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

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

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

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

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

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

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

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

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

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

Алгоритм:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Недостатки:

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

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

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

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

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

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

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

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

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

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

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

* число процессоров [1 : 48] с шагом 1;
* размерность пространства [3 : 50] c шагом 3;
* число векторов 100 000 000;
* число кластерных центров 30;

В результате проведённых экспериментов был получен следующий диапазон [[Глоссарий#Эффективность реализации|эффективности реализации]] алгоритма (отношение реальной производительности программы к пиковым показателям работы вычислительной системы):

* минимальная эффективность реализации 0.014;
* максимальная эффективность реализации 0.9;

На следующих рисунках приведены графики [[Глоссарий#Производительность|производительности]] и эффективности выбранной реализации HCM в зависимости от изменяемых параметров запуска.

[[file:GFLOPS_AA.png|thumb|center|700px|Рисунок 2. Параллельная реализация алгоритма. Изменение производительности в зависимости от числа процессоров и размерности векторов.]]
[[file:EFFICIENCY.png|thumb|center|700px|Рисунок 3. Параллельная реализация алгоритма. Изменение эффективности в зависимости от числа процессоров и размерности векторов.]]

==== Реализация на языке C++ ====
[http://pastebin.com/31UkHgcW Исследованная параллельная реализация на языке C++]

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

=== Существующие реализации алгоритма ===
* [http://projects.jasmeet.me/2013/03/HardCMeans.html Последовательная реализация алгоритма на MatLab]
* [https://github.com/artpar/Hard-Clustering-implementation Последовательная реализация алгоритма на С++]

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

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

2016-11-22T20:14:36Z

Каледа Александр: /* Масштабируемость алгоритма и его реализации */

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

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

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

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

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

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

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

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

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

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

Алгоритм:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Недостатки:

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

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

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

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

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

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

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

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

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

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

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

* число процессоров [1 : 48] с шагом 1;
* размерность пространства [3 : 50] c шагом 3;
* число векторов 100 000 000;
* число кластерных центров 30;

В результате проведённых экспериментов был получен следующий диапазон [[Глоссарий#Эффективность реализации|эффективности реализации]] алгоритма:

* минимальная эффективность реализации 0.014;
* максимальная эффективность реализации 0.9;

На следующих рисунках приведены графики [[Глоссарий#Производительность|производительности]] и эффективности выбранной реализации HCM в зависимости от изменяемых параметров запуска.

[[file:GFLOPS_AA.png|thumb|center|700px|Рисунок 2. Параллельная реализация алгоритма. Изменение производительности в зависимости от числа процессоров и размерности векторов.]]
[[file:EFFICIENCY.png|thumb|center|700px|Рисунок 3. Параллельная реализация алгоритма. Изменение эффективности в зависимости от числа процессоров и размерности векторов.]]

==== Реализация на языке C++ ====
[http://pastebin.com/31UkHgcW Исследованная параллельная реализация на языке C++]

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

=== Существующие реализации алгоритма ===
* [http://projects.jasmeet.me/2013/03/HardCMeans.html Последовательная реализация алгоритма на MatLab]
* [https://github.com/artpar/Hard-Clustering-implementation Последовательная реализация алгоритма на С++]

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

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

2016-11-22T19:55:51Z

Каледа Александр: /* Общее описание алгоритма */

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

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

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

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

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

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

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

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

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

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

Алгоритм:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Недостатки:

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

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

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

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

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

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

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

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

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

* число процессоров [1 : 48] с шагом 1;
* размерность пространства [3 : 50] c шагом 3;
* число векторов 100 000 000;
* число кластерных центров 30;

В результате проведённых экспериментов был получен следующий диапазон [[Глоссарий#Эффективность реализации|эффективности реализации]] алгоритма:

* минимальная эффективность реализации 0.014;
* максимальная эффективность реализации 0.9;

На следующих рисунках приведены графики [[Глоссарий#Производительность|производительности]] и эффективности выбранной реализации HCM в зависимости от изменяемых параметров запуска.

[[file:GFLOPS_AA.png|thumb|center|700px|Рисунок 2. Параллельная реализация алгоритма. Изменение производительности в зависимости от числа процессоров и размерности векторов.]]
[[file:EFFICIENCY.png|thumb|center|700px|Рисунок 3. Параллельная реализация алгоритма. Изменение эффективности в зависимости от числа процессоров и размерности векторов.]]

==== Реализация на языке C++ ====
[http://pastebin.com/31UkHgcW Исследованная параллельная реализация на языке C++]

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

=== Существующие реализации алгоритма ===
* [http://projects.jasmeet.me/2013/03/HardCMeans.html Последовательная реализация алгоритма на MatLab]
* [https://github.com/artpar/Hard-Clustering-implementation Последовательная реализация алгоритма на С++]

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

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

2016-11-22T19:51:46Z

Каледа Александр: /* Масштабируемость алгоритма и его реализации */

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

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

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

=== Общее описание алгоритма ===
'''Строгий алгоритм C средних''' ('''''Hard C-Means, HCM'''''; ''Jang, Sun and Mizutani, 1997'') один из наиболее широко используемых алгоритмов кластеризации данных<ref>[http://faculty.petra.ac.id/resmana/private/fuzzy/nfmod.pdf Jantzen J. Neurofuzzy Modelling. 1998. Электронное издание. 28 Стр.]</ref>. Алгоритм разбивает большие наборы векторов в многомерном пространстве по заранее заданному количеству кластеров (т.е. является управляемым).

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

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

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

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

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

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

Алгоритм:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Недостатки:

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

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

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

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

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

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

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

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

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

* число процессоров [1 : 48] с шагом 1;
* размерность пространства [3 : 50] c шагом 3;
* число векторов 100 000 000;
* число кластерных центров 30;

В результате проведённых экспериментов был получен следующий диапазон [[Глоссарий#Эффективность реализации|эффективности реализации]] алгоритма:

* минимальная эффективность реализации 0.014;
* максимальная эффективность реализации 0.9;

На следующих рисунках приведены графики [[Глоссарий#Производительность|производительности]] и эффективности выбранной реализации HCM в зависимости от изменяемых параметров запуска.

[[file:GFLOPS_AA.png|thumb|center|700px|Рисунок 2. Параллельная реализация алгоритма. Изменение производительности в зависимости от числа процессоров и размерности векторов.]]
[[file:EFFICIENCY.png|thumb|center|700px|Рисунок 3. Параллельная реализация алгоритма. Изменение эффективности в зависимости от числа процессоров и размерности векторов.]]

==== Реализация на языке C++ ====
[http://pastebin.com/31UkHgcW Исследованная параллельная реализация на языке C++]

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

=== Существующие реализации алгоритма ===
* [http://projects.jasmeet.me/2013/03/HardCMeans.html Последовательная реализация алгоритма на MatLab]
* [https://github.com/artpar/Hard-Clustering-implementation Последовательная реализация алгоритма на С++]

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

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

2016-11-22T19:49:25Z

Каледа Александр: /* Масштабируемость алгоритма и его реализации */

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

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

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

=== Общее описание алгоритма ===
'''Строгий алгоритм C средних''' ('''''Hard C-Means, HCM'''''; ''Jang, Sun and Mizutani, 1997'') один из наиболее широко используемых алгоритмов кластеризации данных<ref>[http://faculty.petra.ac.id/resmana/private/fuzzy/nfmod.pdf Jantzen J. Neurofuzzy Modelling. 1998. Электронное издание. 28 Стр.]</ref>. Алгоритм разбивает большие наборы векторов в многомерном пространстве по заранее заданному количеству кластеров (т.е. является управляемым).

На вход алгоритму подается набор векторов и количество кластеров. Дополнительно может задаваться пороговая величина объектной функции, при достижении которой алгоритм останавливается. После окончания работы алгоритма каждый вектор будет отнесет к определенному кластерному центру. Алгоритм, являясь итерационным, зависит от начальных значений кластерных центров, а следовательно может не сходиться к локальному минимуму.

На первом шаге алгоритма происходит инициализация кластерным центров, это можно сделать выбрав случайным образом вектора из входного набора. На следующем шаге начинается итерационный процесс, завершающийся при достижении порогового значения объектной функцией или при минимальном отличии, от значения на предыдущей итерации.

Вычисления, выполняющиеся на очередной итерации алгоритма:

# Расчёт рядовой матрицы (сопоставление вектора соответствующему кластерному центру).
# Расчёт объектной функции.
# Пересчёт кластерных центров.

=== Математическое описание алгоритма ===
Исходные данные: матрица <math>U\in \mathbb{R}^{n\times m}</math>, представляющая собой набор векторов <math>\{u_i\}_{i=1}^{n}, u_i \in \mathbb{R}^m</math>; количество кластеров <math>C \in \mathbb{N}</math>.

Вычисляемые данные: набор векторов - кластерных центров <math>\{c_i\}_{i=1}^{C}, c_i \in \mathbb{R}^m</math>; матрица <math>M\in \mathbb{N}^{n\times C}</math> c информацией о разбиении объектов на кластера. Элемент <math>m_{ij}=1</math>, если <math>u_j \in C_i</math>, где <math>C_i</math> содержит все объекты <math>u</math>, принадлежащие кластеру <math>i</math>. Остальные элементы <math>m_{ij}=0</math>.

Алгоритм:

Шаг 1. Инициализация кластерных центров <math>c_i, i = 1, 2, \dots, C.</math> Это можно сделать выбрав случайным образом C векторов из входного набора <math>\{u_i\}_{i=1}^{n}</math>

Шаг 2. Вычисление рядовой матрицы M.

Матрица <math>M</math> состоит из элементов <math>M = \|m_{ik}\|</math>.

:<math>
m_{ik} = \begin{cases}
1, & \|u_k-c_i\|^2 \leqslant \|u_k-c_j\|^2 \;\; \text{for all } i \neq j; \;\; (i,j=1,2,\ldots,C; \; k = 1,2,\ldots,n)\\
0, & \text{otherwise}.
\end{cases}
</math>

Шаг 3. Расчет объектной функции:

:<math>
J = \sum\limits_{i=1}^C J_i = \sum\limits_{i=1}^C \left( \sum\limits_{k:\, u_k \in C_i} \|u_k -c_i \|^2 \right)</math>.

На этом шаге происходит остановка и выход из цикла, если полученное значение ниже пороговой величины или полученное значение не сильно отличается от значений, полученных на предыдущих циклах.

Шаг 4. Пересчет кластерных центров.

Пересчет кластерных центров выполняется в соответствии со следующим уравнением:
:<math>
c_i = \frac{1}{|C_i|} \sum\limits_{k:\, u_k \in C_i} u_k,
</math>
где <math>|C_i|</math> -- количество элементов в <math>i</math>-ом кластере.

Шаг 5. Переход на шаг 2.

Описание взято из <ref>[http://it-claim.ru/Persons/Neyskiy/Article2_Neiskiy.pdf Нейский И.М. Классификация и сравнение методов кластеризации // Интеллектуальные технологии и системы. Сборник учебно-методических работ и статей аспирантов и студентов. – М.: НОК «CLAIM», 2006. – Выпуск 8. – С. 130-142.]</ref>.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма Hard C-Means можно составить из множественных (всего их <math>nC</math>) вычислений квадратов нормы разности векторов <math>u_k</math> и кластерных центров <math>c_i</math>: <math>\|u_k-c_i\|^2</math>.

=== Макроструктура алгоритма ===
Как записано и в описании ядра алгоритма, основную часть метода составляют множественные (<math>Cn</math>) вычисления квадратов норм:

:<math>\|u_k-c_i\|^2</math>.

Также присутствуют данные вычислительные операции:

* Суммирование квадратов норм векторов:

:<math>
J = \sum\limits_{i=1}^C J_i = \sum\limits_{i=1}^C \left( \sum\limits_{k:\, u_k \in C_i} \|u_k -c_i \|^2 \right)
</math>

* Поэлементное суммирование векторов:

:<math>
c_i = \frac{1}{|C_i|} \sum\limits_{k:\, u_k \in C_i} u_k
</math>

=== Схема реализации последовательного алгоритма ===
Итерационный блок алгоритма можно описать на языке Python следующим образом:

<source lang="python3">
for i in range(n):
idx_min = 0
dist_min = ((u[i] - c[0]) ** 2).sum()

for j in range(1, C):
dist = ((u[i] - c[j]) ** 2).sum()
if dist < dist_min:
idx_min = j
dist_min = dist

M[i, idx_min] = 1
c_next[idx_min] += u[i]
c_next_cnt[idx_min] += 1
J += dist_min
</source>

=== Последовательная сложность алгоритма ===
Предполагаем, что предельная точность алгоритма достигаема менее, чем за <math>n</math> итераций. Иначе использование алгоритма можно считать нерациональным. Также предположим, что размерность <math>m</math> и количество кластерных центров <math>C</math> существенно меньше <math>n</math>.

Операция вычисления квадрата нормы разности векторов требует выполнения <math>m-1</math> арифметических операций сложения, <math>m</math> операций вычитания и <math>m</math> операций умножения.

Каждая итерация алгоритма требует выполнения:
* <math>nC</math> операций вычисления квадрата нормы разности векторов;
* <math>nC</math> операций сравнения квадрата нормы;
* <math>3n</math> операций сложения;

Таким образом, на каждой итерации имеем:
* <math>mnC</math> операций умножения;
* <math>(2mC + 3)n</math> арифметических операций сложения и вычитания;

В итоге имеем сложность последовательной реализации алгоритма <math>O(n)</math>.

=== Информационный граф ===
Граф алгоритма состоит из 4 видов вершин:

'''Первая''' группа вершин отмечена символом '''''M'''''. Ей соответствует вычисление минимального расстояния до кластерных центров, а также запись единицы в соответствующий столбец матрицы, обозначающей принадлежность кластерному центру:
* независимое вычисление расстояний от заданного элемента <math>u_i</math> до каждого из кластерных центров;
* последовательное сравнение полученных значений с целью отыскания максимума;
* операция записи 1 в соответствующий столбец матрицы принадлежности кластерным центрам;

'''Вторая''' вершина отмечена символом '''''J''''', на этом этапе происходит итоговый расчёт объектной функции.

'''Третья''' вершина помечена '''''if''''', на этом этапе происходит проверка условия достижения требуемой точности.

'''Четвертая''' соответствует операции пересчёта кластерных центров, она отмечена как '''''C'''''.

[[File:Cmeans.png|thumb|800px|center|Рисунок 1. Информационный граф алгоритма. Здесь '''''in''''' — ввод входных данных, '''''D''''' — вычисление минимального расстояния до кластерных центров и проставление принадлежности соответствующему кластерному центру, '''''J''''' — вычисление объектной функции по результатам полученных вычислений, '''''if''''' — проверка условия достижения желаемой точности, '''''C''''' — пересчёт кластерных центров и '''''out''''' — вывод полученных данных.]]

=== Ресурс параллелизма алгоритма ===
Основной ресурс параллелизма алгоритма составляет итерационный блок. Эта последовательность итераций может быть выполнена для каждого входного вектора <math>u_i</math> независимо. Однако, в конце выполнения каждого итерационного блока имеют место последовательные вычисления - сложение значений объектной функции, полученных независимо на каждом процессоре, а также перерасчет кластерных центров.

Высота [[глоссарий#Ярусно-параллельная форма графа алгоритма|ЯПФ]] оценивается как <math>O(1)</math> (при условии, что число итераций существенно меньше объёма выборки <math>n</math>). Ширина [[глоссарий#Ярусно-параллельная форма графа алгоритма|ЯПФ]] равна <math>n</math>.

Необходимо учитывать, что при небольшом объеме входной выборки, параллельная реализация алгоритма может лишь понизить производительность. В первую очередь это связано с пересылкой данных для вычисления итоговых значений объектной функции и кластерных центров.

=== Входные и выходные данные алгоритма ===
'''Входные данные:''' матрица <math>U\in \mathbb{R}^{n\times m}</math>, представляющая собой набор векторов <math>\{u_i\}_{i=1}^{n}, u_i \in \mathbb{R}^m</math>; количество кластеров <math>C \in \mathbb{N}</math>.

'''Объём входных данных:''' <math>nm+1</math>.

'''Выходные данные:''' набор векторов - кластерных центров <math>\{c_i\}_{i=1}^{C}, c_i \in \mathbb{R}^m</math>; матрица <math>M\in \mathbb{N}^{n\times C}</math> c информацией о разбиении объектов на кластера. Элемент <math>m_{ij}=1</math>, если <math>u_j \in C_i</math>, где <math>C_i</math> содержит все объекты <math>u</math>, принадлежащие кластеру <math>i</math>. Остальные элементы <math>m_{ij}=0</math>.

'''Объём выходных данных:''' <math>(n+m)C</math>.

=== Свойства алгоритма ===
Достоинства:

* лёгкость реализации;
* вычислительная простота;
* может служить для кластеризации больших наборов числовых данных;

Недостатки:

* задание количества кластеров;
* отсутствие гарантии в нахождении оптимального решения;

Соотношение последовательной и параллельной сложности алгоритма: линейное.

Вычислительная мощность алгоритма, как отношение числа операций к суммарному объему входных и выходных данных равна константе.

Алгоритм является недетерминированным, т.к. он является итерационным с выходом по точности, а также использует датчик случайных чисел для инициализации кластерных центров.

== Программная реализация алгоритма ==

=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
==== Локальность реализации алгоритма ====
===== Структура обращений в память и качественная оценка локальности =====
===== Количественная оценка локальности =====
=== Возможные способы и особенности параллельной реализации алгоритма ===

=== Масштабируемость алгоритма и его реализации ===

==== Масштабируемость реализации алгоритма ====
Проведём исследование масштабируемости параллельной реализации строгого алгоритма C средних согласно [[Scalability methodology|методике]].

Исследование проводилось на 1U сервере со следующими характеристиками:
* 2 x Intel® Xeon® Processor E5-2697 v2;
* 128GB RAM;

Набор и границы значений изменяемых [[Глоссарий#Параметры запуска|параметров запуска]] реализации алгоритма:

* число процессоров [1 : 48] с шагом 1;
* размерность пространства [3 : 50] c шагом 3;
* число векторов 100 000 000;
* число кластерных центров 30;

В результате проведённых экспериментов был получен следующий диапазон [[Глоссарий#Эффективность реализации|эффективности реализации]] алгоритма:

* минимальная эффективность реализации 0.014;
* максимальная эффективность реализации 0.9;

На следующих рисунках приведены графики [[Глоссарий#Производительность|производительности]] и эффективности выбранной реализации HCM в зависимости от изменяемых параметров запуска.

[[file:GFLOPS_AA.png|thumb|center|700px|Рисунок 2. Параллельная реализация алгоритма. Изменение производительности в зависимости от числа процессоров и размерности векторов.]]
[[file:EFFICIENCY.png|thumb|center|700px|Рисунок 3. Параллельная реализация алгоритма. Изменение эффективности в зависимости от числа процессоров и размерности векторов.]]

==== Реализация на языке C++ ====
[http://pastebin.com/31UkHgcW Исследованная параллельная реализация на языке C++]

=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===

=== Существующие реализации алгоритма ===
* [http://projects.jasmeet.me/2013/03/HardCMeans.html Последовательная реализация алгоритма на MatLab]
* [https://github.com/artpar/Hard-Clustering-implementation Последовательная реализация алгоритма на С++]

== Литература ==
<references />

Участник:Каледа Александр/Строгий алгоритм С средних (Hard C-Means)

2016-11-18T20:21:48Z

Каледа Александр: /* Масштабируемость реализации алгоритма */

{{algorithm
| name = Строгий алгоритм С средних (Hard C-Means)
| serial_complexity = <math>O(n)</math>
| pf_height = <math>O(1)</math>
| pf_width = <math>O(n)</math>
| input_data = <math>nm+1</math>
| output_data = <math>(n+m)C</math>
}}

Авторы описания: [[Участник:Каледа_Александр|Каледа Александр]] (разделы [[#Общее описание алгоритма|1.1]], [[#Схема реализации последовательного алгоритма|1.5]], [[#Последовательная сложность алгоритма|1.6]], [[#Информационный граф|1.7]], [[#Ресурс параллелизма алгоритма|1.8]], [[#Входные и выходные данные алгоритма|1.9]]), [[Участник:Шапулин_Андрей|Шапулин Андрей]] (разделы [[#Математическое описание алгоритма|1.2]], [[#Вычислительное ядро алгоритма|1.3]], [[#Макроструктура алгоритма|1.4]], [[#Информационный граф|1.7]], [[#Свойства алгоритма|1.10]], [[#Существующие реализации алгоритма|2.7]]).

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===
'''Строгий алгоритм C средних''' ('''''Hard C-Means, HCM'''''; ''Jang, Sun and Mizutani, 1997'') один из наиболее широко используемых алгоритмов кластеризации данных<ref>[http://faculty.petra.ac.id/resmana/private/fuzzy/nfmod.pdf Jantzen J. Neurofuzzy Modelling. 1998. Электронное издание. 28 Стр.]</ref>. Алгоритм разбивает большие наборы векторов в многомерном пространстве по заранее заданному количеству кластеров (т.е. является управляемым).

На вход алгоритму подается набор векторов и количество кластеров. Дополнительно может задаваться пороговая величина объектной функции, при достижении которой алгоритм останавливается. После окончания работы алгоритма каждый вектор будет отнесет к определенному кластерному центру. Алгоритм, являясь итерационным, зависит от начальных значений кластерных центров, а следовательно может не сходиться к локальному минимуму.

На первом шаге алгоритма происходит инициализация кластерным центров, это можно сделать выбрав случайным образом вектора из входного набора. На следующем шаге начинается итерационный процесс, завершающийся при достижении порогового значения объектной функцией или при минимальном отличии, от значения на предыдущей итерации.

Вычисления, выполняющиеся на очередной итерации алгоритма:

# Расчёт рядовой матрицы (сопоставление вектора соответствующему кластерному центру).
# Расчёт объектной функции.
# Пересчёт кластерных центров.

=== Математическое описание алгоритма ===
Исходные данные: матрица <math>U\in \mathbb{R}^{n\times m}</math>, представляющая собой набор векторов <math>\{u_i\}_{i=1}^{n}, u_i \in \mathbb{R}^m</math>; количество кластеров <math>C \in \mathbb{N}</math>.

Вычисляемые данные: набор векторов - кластерных центров <math>\{c_i\}_{i=1}^{C}, c_i \in \mathbb{R}^m</math>; матрица <math>M\in \mathbb{N}^{n\times C}</math> c информацией о разбиении объектов на кластера. Элемент <math>m_{ij}=1</math>, если <math>u_j \in C_i</math>, где <math>C_i</math> содержит все объекты <math>u</math>, принадлежащие кластеру <math>i</math>. Остальные элементы <math>m_{ij}=0</math>.

Алгоритм:

Шаг 1. Инициализация кластерных центров <math>c_i, i = 1, 2, \dots, C.</math> Это можно сделать выбрав случайным образом C векторов из входного набора <math>\{u_i\}_{i=1}^{n}</math>

Шаг 2. Вычисление рядовой матрицы M.

Матрица <math>M</math> состоит из элементов <math>M = \|m_{ik}\|</math>.

:<math>
m_{ik} = \begin{cases}
1, & \|u_k-c_i\|^2 \leqslant \|u_k-c_j\|^2 \;\; \text{for all } i \neq j; \;\; (i,j=1,2,\ldots,C; \; k = 1,2,\ldots,n)\\
0, & \text{otherwise}.
\end{cases}
</math>

Шаг 3. Расчет объектной функции:

:<math>
J = \sum\limits_{i=1}^C J_i = \sum\limits_{i=1}^C \left( \sum\limits_{k:\, u_k \in C_i} \|u_k -c_i \|^2 \right)</math>.

На этом шаге происходит остановка и выход из цикла, если полученное значение ниже пороговой величины или полученное значение не сильно отличается от значений, полученных на предыдущих циклах.

Шаг 4. Пересчет кластерных центров.

Пересчет кластерных центров выполняется в соответствии со следующим уравнением:
:<math>
c_i = \frac{1}{|C_i|} \sum\limits_{k:\, u_k \in C_i} u_k,
</math>
где <math>|C_i|</math> -- количество элементов в <math>i</math>-ом кластере.

Шаг 5. Переход на шаг 2.

Описание взято из <ref>[http://it-claim.ru/Persons/Neyskiy/Article2_Neiskiy.pdf Нейский И.М. Классификация и сравнение методов кластеризации // Интеллектуальные технологии и системы. Сборник учебно-методических работ и статей аспирантов и студентов. – М.: НОК «CLAIM», 2006. – Выпуск 8. – С. 130-142.]</ref>.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма Hard C-Means можно составить из множественных (всего их <math>nC</math>) вычислений квадратов нормы разности векторов <math>u_k</math> и кластерных центров <math>c_i</math>: <math>\|u_k-c_i\|^2</math>.

=== Макроструктура алгоритма ===
Как записано и в описании ядра алгоритма, основную часть метода составляют множественные (<math>Cn</math>) вычисления квадратов норм:

:<math>\|u_k-c_i\|^2</math>.

Также присутствуют данные вычислительные операции:

* Суммирование квадратов норм векторов:

:<math>
J = \sum\limits_{i=1}^C J_i = \sum\limits_{i=1}^C \left( \sum\limits_{k:\, u_k \in C_i} \|u_k -c_i \|^2 \right)
</math>

* Поэлементное суммирование векторов:

:<math>
c_i = \frac{1}{|C_i|} \sum\limits_{k:\, u_k \in C_i} u_k
</math>

=== Схема реализации последовательного алгоритма ===
Итерационный блок алгоритма можно описать на языке Python следующим образом:

<source lang="python3">
for i in range(n):
idx_min = 0
dist_min = ((u[i] - c[0]) ** 2).sum()

for j in range(1, C):
dist = ((u[i] - c[j]) ** 2).sum()
if dist < dist_min:
idx_min = j
dist_min = dist

M[i, idx_min] = 1
c_next[idx_min] += u[i]
c_next_cnt[idx_min] += 1
J += dist_min
</source>

=== Последовательная сложность алгоритма ===
Предполагаем, что предельная точность алгоритма достигаема менее, чем за <math>n</math> итераций. Иначе использование алгоритма можно считать нерациональным. Также предположим, что размерность <math>m</math> и количество кластерных центров <math>C</math> существенно меньше <math>n</math>.

Операция вычисления квадрата нормы разности векторов требует выполнения <math>m-1</math> арифметических операций сложения, <math>m</math> операций вычитания и <math>m</math> операций умножения.

Каждая итерация алгоритма требует выполнения:
* <math>nC</math> операций вычисления квадрата нормы разности векторов;
* <math>nC</math> операций сравнения квадрата нормы;
* <math>3n</math> операций сложения;

Таким образом, на каждой итерации имеем:
* <math>mnC</math> операций умножения;
* <math>(2mC + 3)n</math> арифметических операций сложения и вычитания;

В итоге имеем сложность последовательной реализации алгоритма <math>O(n)</math>.

=== Информационный граф ===
Граф алгоритма состоит из 4 видов вершин:

'''Первая''' группа вершин отмечена символом '''''M'''''. Ей соответствует вычисление минимального расстояния до кластерных центров, а также запись единицы в соответствующий столбец матрицы, обозначающей принадлежность кластерному центру:
* независимое вычисление расстояний от заданного элемента <math>u_i</math> до каждого из кластерных центров;
* последовательное сравнение полученных значений с целью отыскания максимума;
* операция записи 1 в соответствующий столбец матрицы принадлежности кластерным центрам;

'''Вторая''' вершина отмечена символом '''''J''''', на этом этапе происходит итоговый расчёт объектной функции.

'''Третья''' вершина помечена '''''if''''', на этом этапе происходит проверка условия достижения требуемой точности.

'''Четвертая''' соответствует операции пересчёта кластерных центров, она отмечена как '''''C'''''.

[[File:Cmeans.png|thumb|800px|center|Рисунок 1. Информационный граф алгоритма. Здесь '''''in''''' — ввод входных данных, '''''D''''' — вычисление минимального расстояния до кластерных центров и проставление принадлежности соответствующему кластерному центру, '''''J''''' — вычисление объектной функции по результатам полученных вычислений, '''''if''''' — проверка условия достижения желаемой точности, '''''C''''' — пересчёт кластерных центров и '''''out''''' — вывод полученных данных.]]

=== Ресурс параллелизма алгоритма ===
Основной ресурс параллелизма алгоритма составляет итерационный блок. Эта последовательность итераций может быть выполнена для каждого входного вектора <math>u_i</math> независимо. Однако, в конце выполнения каждого итерационного блока имеют место последовательные вычисления - сложение значений объектной функции, полученных независимо на каждом процессоре, а также перерасчет кластерных центров.

Высота [[глоссарий#Ярусно-параллельная форма графа алгоритма|ЯПФ]] оценивается как <math>O(1)</math> (при условии, что число итераций существенно меньше объёма выборки <math>n</math>). Ширина [[глоссарий#Ярусно-параллельная форма графа алгоритма|ЯПФ]] равна <math>n</math>.

Необходимо учитывать, что при небольшом объеме входной выборки, параллельная реализация алгоритма может лишь понизить производительность. В первую очередь это связано с пересылкой данных для вычисления итоговых значений объектной функции и кластерных центров.

=== Входные и выходные данные алгоритма ===
'''Входные данные:''' матрица <math>U\in \mathbb{R}^{n\times m}</math>, представляющая собой набор векторов <math>\{u_i\}_{i=1}^{n}, u_i \in \mathbb{R}^m</math>; количество кластеров <math>C \in \mathbb{N}</math>.

'''Объём входных данных:''' <math>nm+1</math>.

'''Выходные данные:''' набор векторов - кластерных центров <math>\{c_i\}_{i=1}^{C}, c_i \in \mathbb{R}^m</math>; матрица <math>M\in \mathbb{N}^{n\times C}</math> c информацией о разбиении объектов на кластера. Элемент <math>m_{ij}=1</math>, если <math>u_j \in C_i</math>, где <math>C_i</math> содержит все объекты <math>u</math>, принадлежащие кластеру <math>i</math>. Остальные элементы <math>m_{ij}=0</math>.

'''Объём выходных данных:''' <math>(n+m)C</math>.

=== Свойства алгоритма ===
Достоинства:

* лёгкость реализации;
* вычислительная простота;
* может служить для кластеризации больших наборов числовых данных;

Недостатки:

* задание количества кластеров;
* отсутствие гарантии в нахождении оптимального решения;

Соотношение последовательной и параллельной сложности алгоритма: линейное.

Вычислительная мощность алгоритма, как отношение числа операций к суммарному объему входных и выходных данных равна константе.

Алгоритм является недетерминированным, т.к. он является итерационным с выходом по точности, а также использует датчик случайных чисел для инициализации кластерных центров.

== Программная реализация алгоритма ==

=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
==== Локальность реализации алгоритма ====
===== Структура обращений в память и качественная оценка локальности =====
===== Количественная оценка локальности =====
=== Возможные способы и особенности параллельной реализации алгоритма ===

=== Масштабируемость алгоритма и его реализации ===

==== Масштабируемость алгоритма ====
==== Масштабируемость реализации алгоритма ====
Проведём исследование масштабируемости параллельной реализации строгого алгоритма C средних согласно [[Scalability methodology|методике]].

Исследование проводилось на 1U сервере со следующими характеристиками:
* 2 x Intel® Xeon® Processor E5-2697 v2;
* 128GB RAM;

Набор и границы значений изменяемых [[Глоссарий#Параметры запуска|параметров запуска]] реализации алгоритма:

* число процессоров [1 : 48] с шагом 1;
* размерность пространства [3 : 50] c шагом 3;
* число векторов 100 000 000;
* число кластерных центров 30;

В результате проведённых экспериментов был получен следующий диапазон [[Глоссарий#Эффективность реализации|эффективности реализации]] алгоритма:

* минимальная эффективность реализации 0.014;
* максимальная эффективность реализации 0.9;

На следующих рисунках приведены графики [[Глоссарий#Производительность|производительности]] и эффективности выбранной реализации HCM в зависимости от изменяемых параметров запуска.

[[file:GFLOPS_AA.png|thumb|center|700px|Рисунок 2. Параллельная реализация алгоритма. Изменение производительности в зависимости от числа процессоров и размерности векторов.]]
[[file:EFFICIENCY.png|thumb|center|700px|Рисунок 3. Параллельная реализация алгоритма. Изменение эффективности в зависимости от числа процессоров и размерности векторов.]]

[http://pastebin.com/31UkHgcW Исследованная параллельная реализация на языке C++]

=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===

=== Существующие реализации алгоритма ===
* [http://projects.jasmeet.me/2013/03/HardCMeans.html Последовательная реализация алгоритма на MatLab]
* [https://github.com/artpar/Hard-Clustering-implementation Последовательная реализация алгоритма на С++]

== Литература ==
<references />

Участник:Каледа Александр/Строгий алгоритм С средних (Hard C-Means)

2016-11-18T20:20:53Z

Каледа Александр: /* Масштабируемость реализации алгоритма */

{{algorithm
| name = Строгий алгоритм С средних (Hard C-Means)
| serial_complexity = <math>O(n)</math>
| pf_height = <math>O(1)</math>
| pf_width = <math>O(n)</math>
| input_data = <math>nm+1</math>
| output_data = <math>(n+m)C</math>
}}

Авторы описания: [[Участник:Каледа_Александр|Каледа Александр]] (разделы [[#Общее описание алгоритма|1.1]], [[#Схема реализации последовательного алгоритма|1.5]], [[#Последовательная сложность алгоритма|1.6]], [[#Информационный граф|1.7]], [[#Ресурс параллелизма алгоритма|1.8]], [[#Входные и выходные данные алгоритма|1.9]]), [[Участник:Шапулин_Андрей|Шапулин Андрей]] (разделы [[#Математическое описание алгоритма|1.2]], [[#Вычислительное ядро алгоритма|1.3]], [[#Макроструктура алгоритма|1.4]], [[#Информационный граф|1.7]], [[#Свойства алгоритма|1.10]], [[#Существующие реализации алгоритма|2.7]]).

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===
'''Строгий алгоритм C средних''' ('''''Hard C-Means, HCM'''''; ''Jang, Sun and Mizutani, 1997'') один из наиболее широко используемых алгоритмов кластеризации данных<ref>[http://faculty.petra.ac.id/resmana/private/fuzzy/nfmod.pdf Jantzen J. Neurofuzzy Modelling. 1998. Электронное издание. 28 Стр.]</ref>. Алгоритм разбивает большие наборы векторов в многомерном пространстве по заранее заданному количеству кластеров (т.е. является управляемым).

На вход алгоритму подается набор векторов и количество кластеров. Дополнительно может задаваться пороговая величина объектной функции, при достижении которой алгоритм останавливается. После окончания работы алгоритма каждый вектор будет отнесет к определенному кластерному центру. Алгоритм, являясь итерационным, зависит от начальных значений кластерных центров, а следовательно может не сходиться к локальному минимуму.

На первом шаге алгоритма происходит инициализация кластерным центров, это можно сделать выбрав случайным образом вектора из входного набора. На следующем шаге начинается итерационный процесс, завершающийся при достижении порогового значения объектной функцией или при минимальном отличии, от значения на предыдущей итерации.

Вычисления, выполняющиеся на очередной итерации алгоритма:

# Расчёт рядовой матрицы (сопоставление вектора соответствующему кластерному центру).
# Расчёт объектной функции.
# Пересчёт кластерных центров.

=== Математическое описание алгоритма ===
Исходные данные: матрица <math>U\in \mathbb{R}^{n\times m}</math>, представляющая собой набор векторов <math>\{u_i\}_{i=1}^{n}, u_i \in \mathbb{R}^m</math>; количество кластеров <math>C \in \mathbb{N}</math>.

Вычисляемые данные: набор векторов - кластерных центров <math>\{c_i\}_{i=1}^{C}, c_i \in \mathbb{R}^m</math>; матрица <math>M\in \mathbb{N}^{n\times C}</math> c информацией о разбиении объектов на кластера. Элемент <math>m_{ij}=1</math>, если <math>u_j \in C_i</math>, где <math>C_i</math> содержит все объекты <math>u</math>, принадлежащие кластеру <math>i</math>. Остальные элементы <math>m_{ij}=0</math>.

Алгоритм:

Шаг 1. Инициализация кластерных центров <math>c_i, i = 1, 2, \dots, C.</math> Это можно сделать выбрав случайным образом C векторов из входного набора <math>\{u_i\}_{i=1}^{n}</math>

Шаг 2. Вычисление рядовой матрицы M.

Матрица <math>M</math> состоит из элементов <math>M = \|m_{ik}\|</math>.

:<math>
m_{ik} = \begin{cases}
1, & \|u_k-c_i\|^2 \leqslant \|u_k-c_j\|^2 \;\; \text{for all } i \neq j; \;\; (i,j=1,2,\ldots,C; \; k = 1,2,\ldots,n)\\
0, & \text{otherwise}.
\end{cases}
</math>

Шаг 3. Расчет объектной функции:

:<math>
J = \sum\limits_{i=1}^C J_i = \sum\limits_{i=1}^C \left( \sum\limits_{k:\, u_k \in C_i} \|u_k -c_i \|^2 \right)</math>.

На этом шаге происходит остановка и выход из цикла, если полученное значение ниже пороговой величины или полученное значение не сильно отличается от значений, полученных на предыдущих циклах.

Шаг 4. Пересчет кластерных центров.

Пересчет кластерных центров выполняется в соответствии со следующим уравнением:
:<math>
c_i = \frac{1}{|C_i|} \sum\limits_{k:\, u_k \in C_i} u_k,
</math>
где <math>|C_i|</math> -- количество элементов в <math>i</math>-ом кластере.

Шаг 5. Переход на шаг 2.

Описание взято из <ref>[http://it-claim.ru/Persons/Neyskiy/Article2_Neiskiy.pdf Нейский И.М. Классификация и сравнение методов кластеризации // Интеллектуальные технологии и системы. Сборник учебно-методических работ и статей аспирантов и студентов. – М.: НОК «CLAIM», 2006. – Выпуск 8. – С. 130-142.]</ref>.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма Hard C-Means можно составить из множественных (всего их <math>nC</math>) вычислений квадратов нормы разности векторов <math>u_k</math> и кластерных центров <math>c_i</math>: <math>\|u_k-c_i\|^2</math>.

=== Макроструктура алгоритма ===
Как записано и в описании ядра алгоритма, основную часть метода составляют множественные (<math>Cn</math>) вычисления квадратов норм:

:<math>\|u_k-c_i\|^2</math>.

Также присутствуют данные вычислительные операции:

* Суммирование квадратов норм векторов:

:<math>
J = \sum\limits_{i=1}^C J_i = \sum\limits_{i=1}^C \left( \sum\limits_{k:\, u_k \in C_i} \|u_k -c_i \|^2 \right)
</math>

* Поэлементное суммирование векторов:

:<math>
c_i = \frac{1}{|C_i|} \sum\limits_{k:\, u_k \in C_i} u_k
</math>

=== Схема реализации последовательного алгоритма ===
Итерационный блок алгоритма можно описать на языке Python следующим образом:

<source lang="python3">
for i in range(n):
idx_min = 0
dist_min = ((u[i] - c[0]) ** 2).sum()

for j in range(1, C):
dist = ((u[i] - c[j]) ** 2).sum()
if dist < dist_min:
idx_min = j
dist_min = dist

M[i, idx_min] = 1
c_next[idx_min] += u[i]
c_next_cnt[idx_min] += 1
J += dist_min
</source>

=== Последовательная сложность алгоритма ===
Предполагаем, что предельная точность алгоритма достигаема менее, чем за <math>n</math> итераций. Иначе использование алгоритма можно считать нерациональным. Также предположим, что размерность <math>m</math> и количество кластерных центров <math>C</math> существенно меньше <math>n</math>.

Операция вычисления квадрата нормы разности векторов требует выполнения <math>m-1</math> арифметических операций сложения, <math>m</math> операций вычитания и <math>m</math> операций умножения.

Каждая итерация алгоритма требует выполнения:
* <math>nC</math> операций вычисления квадрата нормы разности векторов;
* <math>nC</math> операций сравнения квадрата нормы;
* <math>3n</math> операций сложения;

Таким образом, на каждой итерации имеем:
* <math>mnC</math> операций умножения;
* <math>(2mC + 3)n</math> арифметических операций сложения и вычитания;

В итоге имеем сложность последовательной реализации алгоритма <math>O(n)</math>.

=== Информационный граф ===
Граф алгоритма состоит из 4 видов вершин:

'''Первая''' группа вершин отмечена символом '''''M'''''. Ей соответствует вычисление минимального расстояния до кластерных центров, а также запись единицы в соответствующий столбец матрицы, обозначающей принадлежность кластерному центру:
* независимое вычисление расстояний от заданного элемента <math>u_i</math> до каждого из кластерных центров;
* последовательное сравнение полученных значений с целью отыскания максимума;
* операция записи 1 в соответствующий столбец матрицы принадлежности кластерным центрам;

'''Вторая''' вершина отмечена символом '''''J''''', на этом этапе происходит итоговый расчёт объектной функции.

'''Третья''' вершина помечена '''''if''''', на этом этапе происходит проверка условия достижения требуемой точности.

'''Четвертая''' соответствует операции пересчёта кластерных центров, она отмечена как '''''C'''''.

[[File:Cmeans.png|thumb|800px|center|Рисунок 1. Информационный граф алгоритма. Здесь '''''in''''' — ввод входных данных, '''''D''''' — вычисление минимального расстояния до кластерных центров и проставление принадлежности соответствующему кластерному центру, '''''J''''' — вычисление объектной функции по результатам полученных вычислений, '''''if''''' — проверка условия достижения желаемой точности, '''''C''''' — пересчёт кластерных центров и '''''out''''' — вывод полученных данных.]]

=== Ресурс параллелизма алгоритма ===
Основной ресурс параллелизма алгоритма составляет итерационный блок. Эта последовательность итераций может быть выполнена для каждого входного вектора <math>u_i</math> независимо. Однако, в конце выполнения каждого итерационного блока имеют место последовательные вычисления - сложение значений объектной функции, полученных независимо на каждом процессоре, а также перерасчет кластерных центров.

Высота [[глоссарий#Ярусно-параллельная форма графа алгоритма|ЯПФ]] оценивается как <math>O(1)</math> (при условии, что число итераций существенно меньше объёма выборки <math>n</math>). Ширина [[глоссарий#Ярусно-параллельная форма графа алгоритма|ЯПФ]] равна <math>n</math>.

Необходимо учитывать, что при небольшом объеме входной выборки, параллельная реализация алгоритма может лишь понизить производительность. В первую очередь это связано с пересылкой данных для вычисления итоговых значений объектной функции и кластерных центров.

=== Входные и выходные данные алгоритма ===
'''Входные данные:''' матрица <math>U\in \mathbb{R}^{n\times m}</math>, представляющая собой набор векторов <math>\{u_i\}_{i=1}^{n}, u_i \in \mathbb{R}^m</math>; количество кластеров <math>C \in \mathbb{N}</math>.

'''Объём входных данных:''' <math>nm+1</math>.

'''Выходные данные:''' набор векторов - кластерных центров <math>\{c_i\}_{i=1}^{C}, c_i \in \mathbb{R}^m</math>; матрица <math>M\in \mathbb{N}^{n\times C}</math> c информацией о разбиении объектов на кластера. Элемент <math>m_{ij}=1</math>, если <math>u_j \in C_i</math>, где <math>C_i</math> содержит все объекты <math>u</math>, принадлежащие кластеру <math>i</math>. Остальные элементы <math>m_{ij}=0</math>.

'''Объём выходных данных:''' <math>(n+m)C</math>.

=== Свойства алгоритма ===
Достоинства:

* лёгкость реализации;
* вычислительная простота;
* может служить для кластеризации больших наборов числовых данных;

Недостатки:

* задание количества кластеров;
* отсутствие гарантии в нахождении оптимального решения;

Соотношение последовательной и параллельной сложности алгоритма: линейное.

Вычислительная мощность алгоритма, как отношение числа операций к суммарному объему входных и выходных данных равна константе.

Алгоритм является недетерминированным, т.к. он является итерационным с выходом по точности, а также использует датчик случайных чисел для инициализации кластерных центров.

== Программная реализация алгоритма ==

=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
==== Локальность реализации алгоритма ====
===== Структура обращений в память и качественная оценка локальности =====
===== Количественная оценка локальности =====
=== Возможные способы и особенности параллельной реализации алгоритма ===

=== Масштабируемость алгоритма и его реализации ===

==== Масштабируемость алгоритма ====
==== Масштабируемость реализации алгоритма ====
Проведём исследование масштабируемости параллельной реализации строгого алгоритма C средних согласно [[Scalability methodology|методике]].

Исследование проводилось на 1U сервере со следующими характеристиками:
* 2 x Intel® Xeon® Processor E5-2697 v2
* 128GB RAM

Набор и границы значений изменяемых [[Глоссарий#Параметры запуска|параметров запуска]] реализации алгоритма:

* число процессоров [1 : 48] с шагом 1;
* размерность пространства [3 : 50] c шагом 3;
* число векторов 100 000 000;
* число кластерных центров 30;

В результате проведённых экспериментов был получен следующий диапазон [[Глоссарий#Эффективность реализации|эффективности реализации]] алгоритма:

* минимальная эффективность реализации 0.014;
* максимальная эффективность реализации 0.9;

На следующих рисунках приведены графики [[Глоссарий#Производительность|производительности]] и эффективности выбранной реализации HCM в зависимости от изменяемых параметров запуска.

[[file:GFLOPS_AA.png|thumb|center|700px|Рисунок 2. Параллельная реализация алгоритма. Изменение производительности в зависимости от числа процессоров и размерности векторов.]]
[[file:EFFICIENCY.png|thumb|center|700px|Рисунок 3. Параллельная реализация алгоритма. Изменение эффективности в зависимости от числа процессоров и размерности векторов.]]

[http://pastebin.com/31UkHgcW Исследованная параллельная реализация на языке C++]

=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===

=== Существующие реализации алгоритма ===
* [http://projects.jasmeet.me/2013/03/HardCMeans.html Последовательная реализация алгоритма на MatLab]
* [https://github.com/artpar/Hard-Clustering-implementation Последовательная реализация алгоритма на С++]

== Литература ==
<references />

Участник:Каледа Александр/Строгий алгоритм С средних (Hard C-Means)

2016-11-15T22:09:35Z

Каледа Александр:

{{Assignment}}

{{algorithm
| name = Строгий алгоритм С средних (Hard C-Means)
| serial_complexity = <math>O(n)</math>
| pf_height = <math>O(1)</math>
| pf_width = <math>O(n)</math>
| input_data = <math>nm+1</math>
| output_data = <math>(n+m)C</math>
}}

Авторы описания: [[Участник:Каледа_Александр|Каледа Александр]] (разделы [[#Общее описание алгоритма|1.1]], [[#Схема реализации последовательного алгоритма|1.5]], [[#Последовательная сложность алгоритма|1.6]], [[#Информационный граф|1.7]], [[#Ресурс параллелизма алгоритма|1.8]], [[#Входные и выходные данные алгоритма|1.9]]), [[Участник:Шапулин_Андрей|Шапулин Андрей]] (разделы [[#Математическое описание алгоритма|1.2]], [[#Вычислительное ядро алгоритма|1.3]], [[#Макроструктура алгоритма|1.4]], [[#Информационный граф|1.7]], [[#Свойства алгоритма|1.10]], [[#Существующие реализации алгоритма|2.7]]).

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===
'''Строгий алгоритм C средних''' ('''''Hard C-Means, HCM'''''; ''Jang, Sun and Mizutani, 1997'') один из наиболее широко используемых алгоритмов кластеризации данных<ref>[http://faculty.petra.ac.id/resmana/private/fuzzy/nfmod.pdf Jantzen J. Neurofuzzy Modelling. 1998. Электронное издание. 28 Стр.]</ref>. Алгоритм разбивает большие наборы векторов в многомерном пространстве по заранее заданному количеству кластеров (т.е. является управляемым).

На вход алгоритму подается набор векторов и количество кластеров. Дополнительно может задаваться пороговая величина объектной функции, при достижении которой алгоритм останавливается. После окончания работы алгоритма каждый вектор будет отнесет к определенному кластерному центру. Алгоритм, являясь итерационным, зависит от начальных значений кластерных центров, а следовательно может не сходиться к локальному минимуму.

На первом шаге алгоритма происходит инициализация кластерным центров, это можно сделать выбрав случайным образом вектора из входного набора. На следующем шаге начинается итерационный процесс, завершающийся при достижении порогового значения объектной функцией или при минимальном отличии, от значения на предыдущей итерации.

Вычисления, выполняющиеся на очередной итерации алгоритма:

# Расчёт рядовой матрицы (сопоставление вектора соответствующему кластерному центру).
# Расчёт объектной функции.
# Пересчёт кластерных центров.

=== Математическое описание алгоритма ===
Исходные данные: матрица <math>U\in \mathbb{R}^{n\times m}</math>, представляющая собой набор векторов <math>\{u_i\}_{i=1}^{n}, u_i \in \mathbb{R}^m</math>; количество кластеров <math>C \in \mathbb{N}</math>.

Вычисляемые данные: набор векторов - кластерных центров <math>\{c_i\}_{i=1}^{C}, c_i \in \mathbb{R}^m</math>; матрица <math>M\in \mathbb{N}^{n\times C}</math> c информацией о разбиении объектов на кластера. Элемент <math>m_{ij}=1</math>, если <math>u_j \in C_i</math>, где <math>C_i</math> содержит все объекты <math>u</math>, принадлежащие кластеру <math>i</math>. Остальные элементы <math>m_{ij}=0</math>.

Алгоритм:

Шаг 1. Инициализация кластерных центров <math>c_i, i = 1, 2, \dots, C.</math> Это можно сделать выбрав случайным образом C векторов из входного набора <math>\{u_i\}_{i=1}^{n}</math>

Шаг 2. Вычисление рядовой матрицы M.

Матрица <math>M</math> состоит из элементов <math>M = \|m_{ik}\|</math>.

:<math>
m_{ik} = \begin{cases}
1, & \|u_k-c_i\|^2 \leqslant \|u_k-c_j\|^2 \;\; \text{for all } i \neq j; \;\; (i,j=1,2,\ldots,C; \; k = 1,2,\ldots,n)\\
0, & \text{otherwise}.
\end{cases}
</math>

Шаг 3. Расчет объектной функции:

:<math>
J = \sum\limits_{i=1}^C J_i = \sum\limits_{i=1}^C \left( \sum\limits_{k:\, u_k \in C_i} \|u_k -c_i \|^2 \right)</math>.

На этом шаге происходит остановка и выход из цикла, если полученное значение ниже пороговой величины или полученное значение не сильно отличается от значений, полученных на предыдущих циклах.

Шаг 4. Пересчет кластерных центров.

Пересчет кластерных центров выполняется в соответствии со следующим уравнением:
:<math>
c_i = \frac{1}{|C_i|} \sum\limits_{k:\, u_k \in C_i} u_k,
</math>
где <math>|C_i|</math> -- количество элементов в <math>i</math>-ом кластере.

Шаг 5. Переход на шаг 2.

Описание взято из <ref>[http://it-claim.ru/Persons/Neyskiy/Article2_Neiskiy.pdf Нейский И.М. Классификация и сравнение методов кластеризации // Интеллектуальные технологии и системы. Сборник учебно-методических работ и статей аспирантов и студентов. – М.: НОК «CLAIM», 2006. – Выпуск 8. – С. 130-142.]</ref>.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма Hard C-Means можно составить из множественных (всего их <math>nC</math>) вычислений квадратов нормы разности векторов <math>u_k</math> и кластерных центров <math>c_i</math>: <math>\|u_k-c_i\|^2</math>.

=== Макроструктура алгоритма ===
Как записано и в описании ядра алгоритма, основную часть метода составляют множественные (<math>Cn</math>) вычисления квадратов норм:

:<math>\|u_k-c_i\|^2</math>.

Также присутствуют данные вычислительные операции:

* Суммирование квадратов норм векторов:

:<math>
J = \sum\limits_{i=1}^C J_i = \sum\limits_{i=1}^C \left( \sum\limits_{k:\, u_k \in C_i} \|u_k -c_i \|^2 \right)
</math>

* Поэлементное суммирование векторов:

:<math>
c_i = \frac{1}{|C_i|} \sum\limits_{k:\, u_k \in C_i} u_k
</math>

=== Схема реализации последовательного алгоритма ===
Итерационный блок алгоритма можно описать на языке Python следующим образом:

<source lang="python3">
for i in range(n):
idx_min = 0
dist_min = ((u[i] - c[0]) ** 2).sum()

for j in range(1, C):
dist = ((u[i] - c[j]) ** 2).sum()
if dist < dist_min:
idx_min = j
dist_min = dist

M[i, idx_min] = 1
c_next[idx_min] += u[i]
c_next_cnt[idx_min] += 1
J += dist_min
</source>

=== Последовательная сложность алгоритма ===
Предполагаем, что предельная точность алгоритма достигаема менее, чем за <math>n</math> итераций. Иначе использование алгоритма можно считать нерациональным. Также предположим, что размерность <math>m</math> и количество кластерных центров <math>C</math> существенно меньше <math>n</math>.

Операция вычисления квадрата нормы разности векторов требует выполнения <math>m-1</math> арифметических операций сложения, <math>m</math> операций вычитания и <math>m</math> операций умножения.

Каждая итерация алгоритма требует выполнения:
* <math>nC</math> операций вычисления квадрата нормы разности векторов;
* <math>nC</math> операций сравнения квадрата нормы;
* <math>3n</math> операций сложения;

Таким образом, на каждой итерации имеем:
* <math>mnC</math> операций умножения;
* <math>(2mC + 3)n</math> арифметических операций сложения и вычитания;

В итоге имеем сложность последовательной реализации алгоритма <math>O(n)</math>.

=== Информационный граф ===
Граф алгоритма состоит из 4 видов вершин:

'''Первая''' группа вершин отмечена символом '''''M'''''. Ей соответствует вычисление минимального расстояния до кластерных центров, а также запись единицы в соответствующий столбец матрицы, обозначающей принадлежность кластерному центру:
* независимое вычисление расстояний от заданного элемента <math>u_i</math> до каждого из кластерных центров;
* последовательное сравнение полученных значений с целью отыскания максимума;
* операция записи 1 в соответствующий столбец матрицы принадлежности кластерным центрам;

'''Вторая''' вершина отмечена символом '''''J''''', на этом этапе происходит итоговый расчёт объектной функции.

'''Третья''' вершина помечена '''''if''''', на этом этапе происходит проверка условия достижения требуемой точности.

'''Четвертая''' соответствует операции пересчёта кластерных центров, она отмечена как '''''C'''''.

[[File:Cmeans.png|thumb|800px|center|Рисунок 1. Информационный граф алгоритма. Здесь '''''in''''' — ввод входных данных, '''''D''''' — вычисление минимального расстояния до кластерных центров и проставление принадлежности соответствующему кластерному центру, '''''J''''' — вычисление объектной функции по результатам полученных вычислений, '''''if''''' — проверка условия достижения желаемой точности, '''''C''''' — пересчёт кластерных центров и '''''out''''' — вывод полученных данных.]]

=== Ресурс параллелизма алгоритма ===
Основной ресурс параллелизма алгоритма составляет итерационный блок. Эта последовательность итераций может быть выполнена для каждого входного вектора <math>u_i</math> независимо. Однако, в конце выполнения каждого итерационного блока имеют место последовательные вычисления - сложение значений объектной функции, полученных независимо на каждом процессоре, а также перерасчет кластерных центров.

Высота [[глоссарий#Ярусно-параллельная форма графа алгоритма|ЯПФ]] оценивается как <math>O(1)</math> (при условии, что число итераций существенно меньше объёма выборки <math>n</math>). Ширина [[глоссарий#Ярусно-параллельная форма графа алгоритма|ЯПФ]] равна <math>n</math>.

Необходимо учитывать, что при небольшом объеме входной выборки, параллельная реализация алгоритма может лишь понизить производительность. В первую очередь это связано с пересылкой данных для вычисления итоговых значений объектной функции и кластерных центров.

=== Входные и выходные данные алгоритма ===
'''Входные данные:''' матрица <math>U\in \mathbb{R}^{n\times m}</math>, представляющая собой набор векторов <math>\{u_i\}_{i=1}^{n}, u_i \in \mathbb{R}^m</math>; количество кластеров <math>C \in \mathbb{N}</math>.

'''Объём входных данных:''' <math>nm+1</math>.

'''Выходные данные:''' набор векторов - кластерных центров <math>\{c_i\}_{i=1}^{C}, c_i \in \mathbb{R}^m</math>; матрица <math>M\in \mathbb{N}^{n\times C}</math> c информацией о разбиении объектов на кластера. Элемент <math>m_{ij}=1</math>, если <math>u_j \in C_i</math>, где <math>C_i</math> содержит все объекты <math>u</math>, принадлежащие кластеру <math>i</math>. Остальные элементы <math>m_{ij}=0</math>.

'''Объём выходных данных:''' <math>(n+m)C</math>.

=== Свойства алгоритма ===
Достоинства:

* лёгкость реализации;
* вычислительная простота;
* может служить для кластеризации больших наборов числовых данных;

Недостатки:

* задание количества кластеров;
* отсутствие гарантии в нахождении оптимального решения;

Соотношение последовательной и параллельной сложности алгоритма: линейное.

Вычислительная мощность алгоритма, как отношение числа операций к суммарному объему входных и выходных данных равна константе.

Алгоритм является недетерминированным, т.к. он является итерационным с выходом по точности, а также использует датчик случайных чисел для инициализации кластерных центров.

== Программная реализация алгоритма ==

=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
==== Локальность реализации алгоритма ====
===== Структура обращений в память и качественная оценка локальности =====
===== Количественная оценка локальности =====
=== Возможные способы и особенности параллельной реализации алгоритма ===

=== Масштабируемость алгоритма и его реализации ===

==== Масштабируемость алгоритма ====
==== Масштабируемость реализации алгоритма ====
Проведём исследование масштабируемости параллельной реализации строгого алгоритма C средних согласно [[Scalability methodology|методике]].

Набор и границы значений изменяемых [[Глоссарий#Параметры запуска|параметров запуска]] реализации алгоритма:

* число процессоров [1 : 48] с шагом 1;
* размерность пространства [3 : 50] c шагом 3;
* число векторов 100 000 000;
* число кластерных центров 30;

В результате проведённых экспериментов был получен следующий диапазон [[Глоссарий#Эффективность реализации|эффективности реализации]] алгоритма:

* минимальная эффективность реализации 0.014;
* максимальная эффективность реализации 0.9.

На следующих рисунках приведены графики [[Глоссарий#Производительность|производительности]] и эффективности выбранной реализации HCM в зависимости от изменяемых параметров запуска.

[[file:GFLOPS_AA.png|thumb|center|700px|Рисунок 2. Параллельная реализация алгоритма. Изменение производительности в зависимости от числа процессоров и размерности векторов.]]
[[file:EFFICIENCY.png|thumb|center|700px|Рисунок 3. Параллельная реализация алгоритма. Изменение эффективности в зависимости от числа процессоров и размерности векторов.]]

=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===

=== Существующие реализации алгоритма ===
* [http://projects.jasmeet.me/2013/03/HardCMeans.html Последовательная реализация алгоритма на MatLab]
* [https://github.com/artpar/Hard-Clustering-implementation Последовательная реализация алгоритма на С++]

== Литература ==
<references />

Участник:Каледа Александр/Строгий алгоритм С средних (Hard C-Means)

2016-11-15T22:07:51Z

Каледа Александр: /* Масштабируемость реализации алгоритма */

{{algorithm
| name = Строгий алгоритм С средних (Hard C-Means)
| serial_complexity = <math>O(n)</math>
| pf_height = <math>O(1)</math>
| pf_width = <math>O(n)</math>
| input_data = <math>nm+1</math>
| output_data = <math>(n+m)C</math>
}}

Авторы описания: [[Участник:Каледа_Александр|Каледа Александр]] (разделы [[#Общее описание алгоритма|1.1]], [[#Схема реализации последовательного алгоритма|1.5]], [[#Последовательная сложность алгоритма|1.6]], [[#Информационный граф|1.7]], [[#Ресурс параллелизма алгоритма|1.8]], [[#Входные и выходные данные алгоритма|1.9]]), [[Участник:Шапулин_Андрей|Шапулин Андрей]] (разделы [[#Математическое описание алгоритма|1.2]], [[#Вычислительное ядро алгоритма|1.3]], [[#Макроструктура алгоритма|1.4]], [[#Информационный граф|1.7]], [[#Свойства алгоритма|1.10]], [[#Существующие реализации алгоритма|2.7]]).

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===
'''Строгий алгоритм C средних''' ('''''Hard C-Means, HCM'''''; ''Jang, Sun and Mizutani, 1997'') один из наиболее широко используемых алгоритмов кластеризации данных<ref>[http://faculty.petra.ac.id/resmana/private/fuzzy/nfmod.pdf Jantzen J. Neurofuzzy Modelling. 1998. Электронное издание. 28 Стр.]</ref>. Алгоритм разбивает большие наборы векторов в многомерном пространстве по заранее заданному количеству кластеров (т.е. является управляемым).

На вход алгоритму подается набор векторов и количество кластеров. Дополнительно может задаваться пороговая величина объектной функции, при достижении которой алгоритм останавливается. После окончания работы алгоритма каждый вектор будет отнесет к определенному кластерному центру. Алгоритм, являясь итерационным, зависит от начальных значений кластерных центров, а следовательно может не сходиться к локальному минимуму.

На первом шаге алгоритма происходит инициализация кластерным центров, это можно сделать выбрав случайным образом вектора из входного набора. На следующем шаге начинается итерационный процесс, завершающийся при достижении порогового значения объектной функцией или при минимальном отличии, от значения на предыдущей итерации.

Вычисления, выполняющиеся на очередной итерации алгоритма:

# Расчёт рядовой матрицы (сопоставление вектора соответствующему кластерному центру).
# Расчёт объектной функции.
# Пересчёт кластерных центров.

=== Математическое описание алгоритма ===
Исходные данные: матрица <math>U\in \mathbb{R}^{n\times m}</math>, представляющая собой набор векторов <math>\{u_i\}_{i=1}^{n}, u_i \in \mathbb{R}^m</math>; количество кластеров <math>C \in \mathbb{N}</math>.

Вычисляемые данные: набор векторов - кластерных центров <math>\{c_i\}_{i=1}^{C}, c_i \in \mathbb{R}^m</math>; матрица <math>M\in \mathbb{N}^{n\times C}</math> c информацией о разбиении объектов на кластера. Элемент <math>m_{ij}=1</math>, если <math>u_j \in C_i</math>, где <math>C_i</math> содержит все объекты <math>u</math>, принадлежащие кластеру <math>i</math>. Остальные элементы <math>m_{ij}=0</math>.

Алгоритм:

Шаг 1. Инициализация кластерных центров <math>c_i, i = 1, 2, \dots, C.</math> Это можно сделать выбрав случайным образом C векторов из входного набора <math>\{u_i\}_{i=1}^{n}</math>

Шаг 2. Вычисление рядовой матрицы M.

Матрица <math>M</math> состоит из элементов <math>M = \|m_{ik}\|</math>.

:<math>
m_{ik} = \begin{cases}
1, & \|u_k-c_i\|^2 \leqslant \|u_k-c_j\|^2 \;\; \text{for all } i \neq j; \;\; (i,j=1,2,\ldots,C; \; k = 1,2,\ldots,n)\\
0, & \text{otherwise}.
\end{cases}
</math>

Шаг 3. Расчет объектной функции:

:<math>
J = \sum\limits_{i=1}^C J_i = \sum\limits_{i=1}^C \left( \sum\limits_{k:\, u_k \in C_i} \|u_k -c_i \|^2 \right)</math>.

На этом шаге происходит остановка и выход из цикла, если полученное значение ниже пороговой величины или полученное значение не сильно отличается от значений, полученных на предыдущих циклах.

Шаг 4. Пересчет кластерных центров.

Пересчет кластерных центров выполняется в соответствии со следующим уравнением:
:<math>
c_i = \frac{1}{|C_i|} \sum\limits_{k:\, u_k \in C_i} u_k,
</math>
где <math>|C_i|</math> -- количество элементов в <math>i</math>-ом кластере.

Шаг 5. Переход на шаг 2.

Описание взято из <ref>[http://it-claim.ru/Persons/Neyskiy/Article2_Neiskiy.pdf Нейский И.М. Классификация и сравнение методов кластеризации // Интеллектуальные технологии и системы. Сборник учебно-методических работ и статей аспирантов и студентов. – М.: НОК «CLAIM», 2006. – Выпуск 8. – С. 130-142.]</ref>.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма Hard C-Means можно составить из множественных (всего их <math>nC</math>) вычислений квадратов нормы разности векторов <math>u_k</math> и кластерных центров <math>c_i</math>: <math>\|u_k-c_i\|^2</math>.

=== Макроструктура алгоритма ===
Как записано и в описании ядра алгоритма, основную часть метода составляют множественные (<math>Cn</math>) вычисления квадратов норм:

:<math>\|u_k-c_i\|^2</math>.

Также присутствуют данные вычислительные операции:

* Суммирование квадратов норм векторов:

:<math>
J = \sum\limits_{i=1}^C J_i = \sum\limits_{i=1}^C \left( \sum\limits_{k:\, u_k \in C_i} \|u_k -c_i \|^2 \right)
</math>

* Поэлементное суммирование векторов:

:<math>
c_i = \frac{1}{|C_i|} \sum\limits_{k:\, u_k \in C_i} u_k
</math>

=== Схема реализации последовательного алгоритма ===
Итерационный блок алгоритма можно описать на языке Python следующим образом:

<source lang="python3">
for i in range(n):
idx_min = 0
dist_min = ((u[i] - c[0]) ** 2).sum()

for j in range(1, C):
dist = ((u[i] - c[j]) ** 2).sum()
if dist < dist_min:
idx_min = j
dist_min = dist

M[i, idx_min] = 1
c_next[idx_min] += u[i]
c_next_cnt[idx_min] += 1
J += dist_min
</source>

=== Последовательная сложность алгоритма ===
Предполагаем, что предельная точность алгоритма достигаема менее, чем за <math>n</math> итераций. Иначе использование алгоритма можно считать нерациональным. Также предположим, что размерность <math>m</math> и количество кластерных центров <math>C</math> существенно меньше <math>n</math>.

Операция вычисления квадрата нормы разности векторов требует выполнения <math>m-1</math> арифметических операций сложения, <math>m</math> операций вычитания и <math>m</math> операций умножения.

Каждая итерация алгоритма требует выполнения:
* <math>nC</math> операций вычисления квадрата нормы разности векторов;
* <math>nC</math> операций сравнения квадрата нормы;
* <math>3n</math> операций сложения;

Таким образом, на каждой итерации имеем:
* <math>mnC</math> операций умножения;
* <math>(2mC + 3)n</math> арифметических операций сложения и вычитания;

В итоге имеем сложность последовательной реализации алгоритма <math>O(n)</math>.

=== Информационный граф ===
Граф алгоритма состоит из 4 видов вершин:

'''Первая''' группа вершин отмечена символом '''''M'''''. Ей соответствует вычисление минимального расстояния до кластерных центров, а также запись единицы в соответствующий столбец матрицы, обозначающей принадлежность кластерному центру:
* независимое вычисление расстояний от заданного элемента <math>u_i</math> до каждого из кластерных центров;
* последовательное сравнение полученных значений с целью отыскания максимума;
* операция записи 1 в соответствующий столбец матрицы принадлежности кластерным центрам;

'''Вторая''' вершина отмечена символом '''''J''''', на этом этапе происходит итоговый расчёт объектной функции.

'''Третья''' вершина помечена '''''if''''', на этом этапе происходит проверка условия достижения требуемой точности.

'''Четвертая''' соответствует операции пересчёта кластерных центров, она отмечена как '''''C'''''.

[[File:Cmeans.png|thumb|800px|center|Рисунок 1. Информационный граф алгоритма. Здесь '''''in''''' — ввод входных данных, '''''D''''' — вычисление минимального расстояния до кластерных центров и проставление принадлежности соответствующему кластерному центру, '''''J''''' — вычисление объектной функции по результатам полученных вычислений, '''''if''''' — проверка условия достижения желаемой точности, '''''C''''' — пересчёт кластерных центров и '''''out''''' — вывод полученных данных.]]

=== Ресурс параллелизма алгоритма ===
Основной ресурс параллелизма алгоритма составляет итерационный блок. Эта последовательность итераций может быть выполнена для каждого входного вектора <math>u_i</math> независимо. Однако, в конце выполнения каждого итерационного блока имеют место последовательные вычисления - сложение значений объектной функции, полученных независимо на каждом процессоре, а также перерасчет кластерных центров.

Высота [[глоссарий#Ярусно-параллельная форма графа алгоритма|ЯПФ]] оценивается как <math>O(1)</math> (при условии, что число итераций существенно меньше объёма выборки <math>n</math>). Ширина [[глоссарий#Ярусно-параллельная форма графа алгоритма|ЯПФ]] равна <math>n</math>.

Необходимо учитывать, что при небольшом объеме входной выборки, параллельная реализация алгоритма может лишь понизить производительность. В первую очередь это связано с пересылкой данных для вычисления итоговых значений объектной функции и кластерных центров.

=== Входные и выходные данные алгоритма ===
'''Входные данные:''' матрица <math>U\in \mathbb{R}^{n\times m}</math>, представляющая собой набор векторов <math>\{u_i\}_{i=1}^{n}, u_i \in \mathbb{R}^m</math>; количество кластеров <math>C \in \mathbb{N}</math>.

'''Объём входных данных:''' <math>nm+1</math>.

'''Выходные данные:''' набор векторов - кластерных центров <math>\{c_i\}_{i=1}^{C}, c_i \in \mathbb{R}^m</math>; матрица <math>M\in \mathbb{N}^{n\times C}</math> c информацией о разбиении объектов на кластера. Элемент <math>m_{ij}=1</math>, если <math>u_j \in C_i</math>, где <math>C_i</math> содержит все объекты <math>u</math>, принадлежащие кластеру <math>i</math>. Остальные элементы <math>m_{ij}=0</math>.

'''Объём выходных данных:''' <math>(n+m)C</math>.

=== Свойства алгоритма ===
Достоинства:

* лёгкость реализации;
* вычислительная простота;
* может служить для кластеризации больших наборов числовых данных;

Недостатки:

* задание количества кластеров;
* отсутствие гарантии в нахождении оптимального решения;

Соотношение последовательной и параллельной сложности алгоритма: линейное.

Вычислительная мощность алгоритма, как отношение числа операций к суммарному объему входных и выходных данных равна константе.

Алгоритм является недетерминированным, т.к. он является итерационным с выходом по точности, а также использует датчик случайных чисел для инициализации кластерных центров.

== Программная реализация алгоритма ==

=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
==== Локальность реализации алгоритма ====
===== Структура обращений в память и качественная оценка локальности =====
===== Количественная оценка локальности =====
=== Возможные способы и особенности параллельной реализации алгоритма ===

=== Масштабируемость алгоритма и его реализации ===

==== Масштабируемость алгоритма ====
==== Масштабируемость реализации алгоритма ====
Проведём исследование масштабируемости параллельной реализации строгого алгоритма C средних согласно [[Scalability methodology|методике]].

Набор и границы значений изменяемых [[Глоссарий#Параметры запуска|параметров запуска]] реализации алгоритма:

* число процессоров [1 : 48] с шагом 1;
* размерность пространства [3 : 50] c шагом 3;
* число векторов 100 000 000;
* число кластерных центров 30;

В результате проведённых экспериментов был получен следующий диапазон [[Глоссарий#Эффективность реализации|эффективности реализации]] алгоритма:

* минимальная эффективность реализации 0.014;
* максимальная эффективность реализации 0.9.

На следующих рисунках приведены графики [[Глоссарий#Производительность|производительности]] и эффективности выбранной реализации HCM в зависимости от изменяемых параметров запуска.

[[file:GFLOPS_AA.png|thumb|center|700px|Рисунок 2. Параллельная реализация алгоритма. Изменение производительности в зависимости от числа процессоров и размерности векторов.]]
[[file:EFFICIENCY.png|thumb|center|700px|Рисунок 3. Параллельная реализация алгоритма. Изменение эффективности в зависимости от числа процессоров и размерности векторов.]]

=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===

=== Существующие реализации алгоритма ===
* [http://projects.jasmeet.me/2013/03/HardCMeans.html Последовательная реализация алгоритма на MatLab]
* [https://github.com/artpar/Hard-Clustering-implementation Последовательная реализация алгоритма на С++]

== Литература ==
<references />

Участник:Каледа Александр/Строгий алгоритм С средних (Hard C-Means)

2016-11-15T18:48:18Z

Каледа Александр: /* Масштабируемость реализации алгоритма */

{{algorithm
| name = Строгий алгоритм С средних (Hard C-Means)
| serial_complexity = <math>O(n)</math>
| pf_height = <math>O(1)</math>
| pf_width = <math>O(n)</math>
| input_data = <math>nm+1</math>
| output_data = <math>(n+m)C</math>
}}

Авторы описания: [[Участник:Каледа_Александр|Каледа Александр]] (разделы [[#Общее описание алгоритма|1.1]], [[#Схема реализации последовательного алгоритма|1.5]], [[#Последовательная сложность алгоритма|1.6]], [[#Информационный граф|1.7]], [[#Ресурс параллелизма алгоритма|1.8]], [[#Входные и выходные данные алгоритма|1.9]]), [[Участник:Шапулин_Андрей|Шапулин Андрей]] (разделы [[#Математическое описание алгоритма|1.2]], [[#Вычислительное ядро алгоритма|1.3]], [[#Макроструктура алгоритма|1.4]], [[#Информационный граф|1.7]], [[#Свойства алгоритма|1.10]], [[#Существующие реализации алгоритма|2.7]]).

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===
'''Строгий алгоритм C средних''' ('''''Hard C-Means, HCM'''''; ''Jang, Sun and Mizutani, 1997'') один из наиболее широко используемых алгоритмов кластеризации данных<ref>[http://faculty.petra.ac.id/resmana/private/fuzzy/nfmod.pdf Jantzen J. Neurofuzzy Modelling. 1998. Электронное издание. 28 Стр.]</ref>. Алгоритм разбивает большие наборы векторов в многомерном пространстве по заранее заданному количеству кластеров (т.е. является управляемым).

На вход алгоритму подается набор векторов и количество кластеров. Дополнительно может задаваться пороговая величина объектной функции, при достижении которой алгоритм останавливается. После окончания работы алгоритма каждый вектор будет отнесет к определенному кластерному центру. Алгоритм, являясь итерационным, зависит от начальных значений кластерных центров, а следовательно может не сходиться к локальному минимуму.

На первом шаге алгоритма происходит инициализация кластерным центров, это можно сделать выбрав случайным образом вектора из входного набора. На следующем шаге начинается итерационный процесс, завершающийся при достижении порогового значения объектной функцией или при минимальном отличии, от значения на предыдущей итерации.

Вычисления, выполняющиеся на очередной итерации алгоритма:

# Расчёт рядовой матрицы (сопоставление вектора соответствующему кластерному центру).
# Расчёт объектной функции.
# Пересчёт кластерных центров.

=== Математическое описание алгоритма ===
Исходные данные: матрица <math>U\in \mathbb{R}^{n\times m}</math>, представляющая собой набор векторов <math>\{u_i\}_{i=1}^{n}, u_i \in \mathbb{R}^m</math>; количество кластеров <math>C \in \mathbb{N}</math>.

Вычисляемые данные: набор векторов - кластерных центров <math>\{c_i\}_{i=1}^{C}, c_i \in \mathbb{R}^m</math>; матрица <math>M\in \mathbb{N}^{n\times C}</math> c информацией о разбиении объектов на кластера. Элемент <math>m_{ij}=1</math>, если <math>u_j \in C_i</math>, где <math>C_i</math> содержит все объекты <math>u</math>, принадлежащие кластеру <math>i</math>. Остальные элементы <math>m_{ij}=0</math>.

Алгоритм:

Шаг 1. Инициализация кластерных центров <math>c_i, i = 1, 2, \dots, C.</math> Это можно сделать выбрав случайным образом C векторов из входного набора <math>\{u_i\}_{i=1}^{n}</math>

Шаг 2. Вычисление рядовой матрицы M.

Матрица <math>M</math> состоит из элементов <math>M = \|m_{ik}\|</math>.

:<math>
m_{ik} = \begin{cases}
1, & \|u_k-c_i\|^2 \leqslant \|u_k-c_j\|^2 \;\; \text{for all } i \neq j; \;\; (i,j=1,2,\ldots,C; \; k = 1,2,\ldots,n)\\
0, & \text{otherwise}.
\end{cases}
</math>

Шаг 3. Расчет объектной функции:

:<math>
J = \sum\limits_{i=1}^C J_i = \sum\limits_{i=1}^C \left( \sum\limits_{k:\, u_k \in C_i} \|u_k -c_i \|^2 \right)</math>.

На этом шаге происходит остановка и выход из цикла, если полученное значение ниже пороговой величины или полученное значение не сильно отличается от значений, полученных на предыдущих циклах.

Шаг 4. Пересчет кластерных центров.

Пересчет кластерных центров выполняется в соответствии со следующим уравнением:
:<math>
c_i = \frac{1}{|C_i|} \sum\limits_{k:\, u_k \in C_i} u_k,
</math>
где <math>|C_i|</math> -- количество элементов в <math>i</math>-ом кластере.

Шаг 5. Переход на шаг 2.

Описание взято из <ref>[http://it-claim.ru/Persons/Neyskiy/Article2_Neiskiy.pdf Нейский И.М. Классификация и сравнение методов кластеризации // Интеллектуальные технологии и системы. Сборник учебно-методических работ и статей аспирантов и студентов. – М.: НОК «CLAIM», 2006. – Выпуск 8. – С. 130-142.]</ref>.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма Hard C-Means можно составить из множественных (всего их <math>nC</math>) вычислений квадратов нормы разности векторов <math>u_k</math> и кластерных центров <math>c_i</math>: <math>\|u_k-c_i\|^2</math>.

=== Макроструктура алгоритма ===
Как записано и в описании ядра алгоритма, основную часть метода составляют множественные (<math>Cn</math>) вычисления квадратов норм:

:<math>\|u_k-c_i\|^2</math>.

Также присутствуют данные вычислительные операции:

* Суммирование квадратов норм векторов:

:<math>
J = \sum\limits_{i=1}^C J_i = \sum\limits_{i=1}^C \left( \sum\limits_{k:\, u_k \in C_i} \|u_k -c_i \|^2 \right)
</math>

* Поэлементное суммирование векторов:

:<math>
c_i = \frac{1}{|C_i|} \sum\limits_{k:\, u_k \in C_i} u_k
</math>

=== Схема реализации последовательного алгоритма ===
Итерационный блок алгоритма можно описать на языке Python следующим образом:

<source lang="python3">
for i in range(n):
idx_min = 0
dist_min = ((u[i] - c[0]) ** 2).sum()

for j in range(1, C):
dist = ((u[i] - c[j]) ** 2).sum()
if dist < dist_min:
idx_min = j
dist_min = dist

M[i, idx_min] = 1
c_next[idx_min] += u[i]
c_next_cnt[idx_min] += 1
J += dist_min
</source>

=== Последовательная сложность алгоритма ===
Предполагаем, что предельная точность алгоритма достигаема менее, чем за <math>n</math> итераций. Иначе использование алгоритма можно считать нерациональным. Также предположим, что размерность <math>m</math> и количество кластерных центров <math>C</math> существенно меньше <math>n</math>.

Операция вычисления квадрата нормы разности векторов требует выполнения <math>m-1</math> арифметических операций сложения, <math>m</math> операций вычитания и <math>m</math> операций умножения.

Каждая итерация алгоритма требует выполнения:
* <math>nC</math> операций вычисления квадрата нормы разности векторов;
* <math>nC</math> операций сравнения квадрата нормы;
* <math>3n</math> операций сложения;

Таким образом, на каждой итерации имеем:
* <math>mnC</math> операций умножения;
* <math>(2mC + 3)n</math> арифметических операций сложения и вычитания;

В итоге имеем сложность последовательной реализации алгоритма <math>O(n)</math>.

=== Информационный граф ===
Граф алгоритма состоит из 4 видов вершин:

'''Первая''' группа вершин отмечена символом '''''M'''''. Ей соответствует вычисление минимального расстояния до кластерных центров, а также запись единицы в соответствующий столбец матрицы, обозначающей принадлежность кластерному центру:
* независимое вычисление расстояний от заданного элемента <math>u_i</math> до каждого из кластерных центров;
* последовательное сравнение полученных значений с целью отыскания максимума;
* операция записи 1 в соответствующий столбец матрицы принадлежности кластерным центрам;

'''Вторая''' вершина отмечена символом '''''J''''', на этом этапе происходит итоговый расчёт объектной функции.

'''Третья''' вершина помечена '''''if''''', на этом этапе происходит проверка условия достижения требуемой точности.

'''Четвертая''' соответствует операции пересчёта кластерных центров, она отмечена как '''''C'''''.

[[File:Cmeans.png|thumb|800px|center|Рисунок 1. Информационный граф алгоритма. Здесь '''''in''''' — ввод входных данных, '''''D''''' — вычисление минимального расстояния до кластерных центров и проставление принадлежности соответствующему кластерному центру, '''''J''''' — вычисление объектной функции по результатам полученных вычислений, '''''if''''' — проверка условия достижения желаемой точности, '''''C''''' — пересчёт кластерных центров и '''''out''''' — вывод полученных данных.]]

=== Ресурс параллелизма алгоритма ===
Основной ресурс параллелизма алгоритма составляет итерационный блок. Эта последовательность итераций может быть выполнена для каждого входного вектора <math>u_i</math> независимо. Однако, в конце выполнения каждого итерационного блока имеют место последовательные вычисления - сложение значений объектной функции, полученных независимо на каждом процессоре, а также перерасчет кластерных центров.

Высота [[глоссарий#Ярусно-параллельная форма графа алгоритма|ЯПФ]] оценивается как <math>O(1)</math> (при условии, что число итераций существенно меньше объёма выборки <math>n</math>). Ширина [[глоссарий#Ярусно-параллельная форма графа алгоритма|ЯПФ]] равна <math>n</math>.

Необходимо учитывать, что при небольшом объеме входной выборки, параллельная реализация алгоритма может лишь понизить производительность. В первую очередь это связано с пересылкой данных для вычисления итоговых значений объектной функции и кластерных центров.

=== Входные и выходные данные алгоритма ===
'''Входные данные:''' матрица <math>U\in \mathbb{R}^{n\times m}</math>, представляющая собой набор векторов <math>\{u_i\}_{i=1}^{n}, u_i \in \mathbb{R}^m</math>; количество кластеров <math>C \in \mathbb{N}</math>.

'''Объём входных данных:''' <math>nm+1</math>.

'''Выходные данные:''' набор векторов - кластерных центров <math>\{c_i\}_{i=1}^{C}, c_i \in \mathbb{R}^m</math>; матрица <math>M\in \mathbb{N}^{n\times C}</math> c информацией о разбиении объектов на кластера. Элемент <math>m_{ij}=1</math>, если <math>u_j \in C_i</math>, где <math>C_i</math> содержит все объекты <math>u</math>, принадлежащие кластеру <math>i</math>. Остальные элементы <math>m_{ij}=0</math>.

'''Объём выходных данных:''' <math>(n+m)C</math>.

=== Свойства алгоритма ===
Достоинства:

* лёгкость реализации;
* вычислительная простота;
* может служить для кластеризации больших наборов числовых данных;

Недостатки:

* задание количества кластеров;
* отсутствие гарантии в нахождении оптимального решения;

Соотношение последовательной и параллельной сложности алгоритма: линейное.

Вычислительная мощность алгоритма, как отношение числа операций к суммарному объему входных и выходных данных равна константе.

Алгоритм является недетерминированным, т.к. он является итерационным с выходом по точности, а также использует датчик случайных чисел для инициализации кластерных центров.

== Программная реализация алгоритма ==

=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
==== Локальность реализации алгоритма ====
===== Структура обращений в память и качественная оценка локальности =====
===== Количественная оценка локальности =====
=== Возможные способы и особенности параллельной реализации алгоритма ===

=== Масштабируемость алгоритма и его реализации ===

==== Масштабируемость алгоритма ====
==== Масштабируемость реализации алгоритма ====
Проведём исследование масштабируемости параллельной реализации строгого алгоритма C средних согласно [[Scalability methodology|методике]].

Набор и границы значений изменяемых [[Глоссарий#Параметры запуска|параметров запуска]] реализации алгоритма:

* число процессоров [1 : 48] с шагом 1;
* размерность пространства [3 : 50] c шагом 3;
* число векторов 100 000 000;
* число кластерных центров 30;

В результате проведённых экспериментов был получен следующий диапазон [[Глоссарий#Эффективность реализации|эффективности реализации]] алгоритма:

* минимальная эффективность реализации %;
* максимальная эффективность реализации %.

На следующих рисунках приведены графики [[Глоссарий#Производительность|производительности]] и эффективности выбранной реализации HCM в зависимости от изменяемых параметров запуска.

=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===

=== Существующие реализации алгоритма ===
* [http://projects.jasmeet.me/2013/03/HardCMeans.html Последовательная реализация алгоритма на MatLab]
* [https://github.com/artpar/Hard-Clustering-implementation Последовательная реализация алгоритма на С++]

== Литература ==
<references />

Участник:Каледа Александр/Строгий алгоритм С средних (Hard C-Means)

2016-11-01T19:13:36Z

Каледа Александр:

{{Assignment}}

{{algorithm
| name = Строгий алгоритм С средних (Hard C-Means)
| serial_complexity = <math>O(n)</math>
| pf_height = <math>O(1)</math>
| pf_width = <math>O(n)</math>
| input_data = <math>nm+1</math>
| output_data = <math>(n+m)C</math>
}}

Авторы описания: [[Участник:Каледа_Александр|Каледа Александр]] (разделы [[#Общее описание алгоритма|1.1]], [[#Схема реализации последовательного алгоритма|1.5]], [[#Последовательная сложность алгоритма|1.6]], [[#Информационный граф|1.7]], [[#Ресурс параллелизма алгоритма|1.8]], [[#Входные и выходные данные алгоритма|1.9]]), [[Участник:Шапулин_Андрей|Шапулин Андрей]] (разделы [[#Математическое описание алгоритма|1.2]], [[#Вычислительное ядро алгоритма|1.3]], [[#Макроструктура алгоритма|1.4]], [[#Информационный граф|1.7]], [[#Свойства алгоритма|1.10]], [[#Существующие реализации алгоритма|2.7]]).

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===
'''Строгий алгоритм C средних''' ('''''Hard C-Means, HCM'''''; ''Jang, Sun and Mizutani, 1997'') один из наиболее широко используемых алгоритмов кластеризации данных<ref>[http://faculty.petra.ac.id/resmana/private/fuzzy/nfmod.pdf Jantzen J. Neurofuzzy Modelling. 1998. Электронное издание. 28 Стр.]</ref>. Алгоритм разбивает большие наборы векторов в многомерном пространстве по заранее заданному количеству кластеров (т.е. является управляемым).

На вход алгоритму подается набор векторов и количество кластеров. Дополнительно может задаваться пороговая величина объектной функции, при достижении которой алгоритм останавливается. После окончания работы алгоритма каждый вектор будет отнесет к определенному кластерному центру. Алгоритм, являясь итерационным, зависит от начальных значений кластерных центров, а следовательно может не сходиться к локальному минимуму.

На первом шаге алгоритма происходит инициализация кластерным центров, это можно сделать выбрав случайным образом вектора из входного набора. На следующем шаге начинается итерационный процесс, завершающийся при достижении порогового значения объектной функцией или при минимальном отличии, от значения на предыдущей итерации.

Вычисления, выполняющиеся на очередной итерации алгоритма:

# Расчёт рядовой матрицы (сопоставление вектора соответствующему кластерному центру).
# Расчёт объектной функции.
# Пересчёт кластерных центров.

=== Математическое описание алгоритма ===
Исходные данные: матрица <math>U\in \mathbb{R}^{n\times m}</math>, представляющая собой набор векторов <math>\{u_i\}_{i=1}^{n}, u_i \in \mathbb{R}^m</math>; количество кластеров <math>C \in \mathbb{N}</math>.

Вычисляемые данные: набор векторов - кластерных центров <math>\{c_i\}_{i=1}^{C}, c_i \in \mathbb{R}^m</math>; матрица <math>M\in \mathbb{N}^{n\times C}</math> c информацией о разбиении объектов на кластера. Элемент <math>m_{ij}=1</math>, если <math>u_j \in C_i</math>, где <math>C_i</math> содержит все объекты <math>u</math>, принадлежащие кластеру <math>i</math>. Остальные элементы <math>m_{ij}=0</math>.

Алгоритм:

Шаг 1. Инициализация кластерных центров <math>c_i, i = 1, 2, \dots, C.</math> Это можно сделать выбрав случайным образом C векторов из входного набора <math>\{u_i\}_{i=1}^{n}</math>

Шаг 2. Вычисление рядовой матрицы M.

Матрица <math>M</math> состоит из элементов <math>M = \|m_{ik}\|</math>.

:<math>
m_{ik} = \begin{cases}
1, & \|u_k-c_i\|^2 \leqslant \|u_k-c_j\|^2 \;\; \text{for all } i \neq j; \;\; (i,j=1,2,\ldots,C; \; k = 1,2,\ldots,n)\\
0, & \text{otherwise}.
\end{cases}
</math>

Шаг 3. Расчет объектной функции:

:<math>
J = \sum\limits_{i=1}^C J_i = \sum\limits_{i=1}^C \left( \sum\limits_{k:\, u_k \in C_i} \|u_k -c_i \|^2 \right)</math>.

На этом шаге происходит остановка и выход из цикла, если полученное значение ниже пороговой величины или полученное значение не сильно отличается от значений, полученных на предыдущих циклах.

Шаг 4. Пересчет кластерных центров.

Пересчет кластерных центров выполняется в соответствии со следующим уравнением:
:<math>
c_i = \frac{1}{|C_i|} \sum\limits_{k:\, u_k \in C_i} u_k,
</math>
где <math>|C_i|</math> -- количество элементов в <math>i</math>-ом кластере.

Шаг 5. Переход на шаг 2.

Описание взято из <ref>[http://it-claim.ru/Persons/Neyskiy/Article2_Neiskiy.pdf Нейский И.М. Классификация и сравнение методов кластеризации // Интеллектуальные технологии и системы. Сборник учебно-методических работ и статей аспирантов и студентов. – М.: НОК «CLAIM», 2006. – Выпуск 8. – С. 130-142.]</ref>.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма Hard C-Means можно составить из множественных (всего их <math>nC</math>) вычислений квадратов нормы разности векторов <math>u_k</math> и кластерных центров <math>c_i</math>: <math>\|u_k-c_i\|^2</math>.

=== Макроструктура алгоритма ===
Как записано и в описании ядра алгоритма, основную часть метода составляют множественные (<math>Cn</math>) вычисления квадратов норм:

:<math>\|u_k-c_i\|^2</math>.

Также присутствуют данные вычислительные операции:

* Суммирование квадратов норм векторов:

:<math>
J = \sum\limits_{i=1}^C J_i = \sum\limits_{i=1}^C \left( \sum\limits_{k:\, u_k \in C_i} \|u_k -c_i \|^2 \right)
</math>

* Поэлементное суммирование векторов:

:<math>
c_i = \frac{1}{|C_i|} \sum\limits_{k:\, u_k \in C_i} u_k
</math>

=== Схема реализации последовательного алгоритма ===
Итерационный блок алгоритма можно описать на языке Python следующим образом:

<source lang="python3">
for i in range(n):
idx_min = 0
dist_min = ((u[i] - c[0]) ** 2).sum()

for j in range(1, C):
dist = ((u[i] - c[j]) ** 2).sum()
if dist < dist_min:
idx_min = j
dist_min = dist

M[i, idx_min] = 1
c_next[idx_min] += u[i]
c_next_cnt[idx_min] += 1
J += dist_min
</source>

=== Последовательная сложность алгоритма ===
Предполагаем, что предельная точность алгоритма достигаема менее, чем за <math>n</math> итераций. Иначе использование алгоритма можно считать нерациональным. Также предположим, что размерность <math>m</math> и количество кластерных центров <math>C</math> существенно меньше <math>n</math>.

Операция вычисления квадрата нормы разности векторов требует выполнения <math>m-1</math> арифметических операций сложения, <math>m</math> операций вычитания и <math>m</math> операций умножения.

Каждая итерация алгоритма требует выполнения:
* <math>nC</math> операций вычисления квадрата нормы разности векторов;
* <math>nC</math> операций сравнения квадрата нормы;
* <math>3n</math> операций сложения;

Таким образом, на каждой итерации имеем:
* <math>mnC</math> операций умножения;
* <math>(2mC + 3)n</math> арифметических операций сложения и вычитания;

В итоге имеем сложность последовательной реализации алгоритма <math>O(n)</math>.

=== Информационный граф ===
Граф алгоритма состоит из 4 видов вершин:

'''Первая''' группа вершин отмечена символом '''''M'''''. Ей соответствует вычисление минимального расстояния до кластерных центров, а также запись единицы в соответствующий столбец матрицы, обозначающей принадлежность кластерному центру:
* независимое вычисление расстояний от заданного элемента <math>u_i</math> до каждого из кластерных центров;
* последовательное сравнение полученных значений с целью отыскания максимума;
* операция записи 1 в соответствующий столбец матрицы принадлежности кластерным центрам;

'''Вторая''' вершина отмечена символом '''''J''''', на этом этапе происходит итоговый расчёт объектной функции.

'''Третья''' вершина помечена '''''if''''', на этом этапе происходит проверка условия достижения требуемой точности.

'''Четвертая''' соответствует операции пересчёта кластерных центров, она отмечена как '''''C'''''.

[[File:Cmeans.png|thumb|800px|center|Рисунок 1. Информационный граф алгоритма. Здесь '''''in''''' — ввод входных данных, '''''D''''' — вычисление минимального расстояния до кластерных центров и проставление принадлежности соответствующему кластерному центру, '''''J''''' — вычисление объектной функции по результатам полученных вычислений, '''''if''''' — проверка условия достижения желаемой точности, '''''C''''' — пересчёт кластерных центров и '''''out''''' — вывод полученных данных.]]

=== Ресурс параллелизма алгоритма ===
Основной ресурс параллелизма алгоритма составляет итерационный блок. Эта последовательность итераций может быть выполнена для каждого входного вектора <math>u_i</math> независимо. Однако, в конце выполнения каждого итерационного блока имеют место последовательные вычисления - сложение значений объектной функции, полученных независимо на каждом процессоре, а также перерасчет кластерных центров.

Высота [[глоссарий#Ярусно-параллельная форма графа алгоритма|ЯПФ]] оценивается как <math>O(1)</math> (при условии, что число итераций существенно меньше объёма выборки <math>n</math>). Ширина [[глоссарий#Ярусно-параллельная форма графа алгоритма|ЯПФ]] равна <math>n</math>.

Необходимо учитывать, что при небольшом объеме входной выборки, параллельная реализация алгоритма может лишь понизить производительность. В первую очередь это связано с пересылкой данных для вычисления итоговых значений объектной функции и кластерных центров.

=== Входные и выходные данные алгоритма ===
'''Входные данные:''' матрица <math>U\in \mathbb{R}^{n\times m}</math>, представляющая собой набор векторов <math>\{u_i\}_{i=1}^{n}, u_i \in \mathbb{R}^m</math>; количество кластеров <math>C \in \mathbb{N}</math>.

'''Объём входных данных:''' <math>nm+1</math>.

'''Выходные данные:''' набор векторов - кластерных центров <math>\{c_i\}_{i=1}^{C}, c_i \in \mathbb{R}^m</math>; матрица <math>M\in \mathbb{N}^{n\times C}</math> c информацией о разбиении объектов на кластера. Элемент <math>m_{ij}=1</math>, если <math>u_j \in C_i</math>, где <math>C_i</math> содержит все объекты <math>u</math>, принадлежащие кластеру <math>i</math>. Остальные элементы <math>m_{ij}=0</math>.

'''Объём выходных данных:''' <math>(n+m)C</math>.

=== Свойства алгоритма ===
Достоинства:

* лёгкость реализации;
* вычислительная простота;
* может служить для кластеризации больших наборов числовых данных;

Недостатки:

* задание количества кластеров;
* отсутствие гарантии в нахождении оптимального решения;

Соотношение последовательной и параллельной сложности алгоритма: линейное.

Вычислительная мощность алгоритма, как отношение числа операций к суммарному объему входных и выходных данных равна константе.

Алгоритм является недетерминированным, т.к. он является итерационным с выходом по точности, а также использует датчик случайных чисел для инициализации кластерных центров.

== Программная реализация алгоритма ==

=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
==== Локальность реализации алгоритма ====
===== Структура обращений в память и качественная оценка локальности =====
===== Количественная оценка локальности =====
=== Возможные способы и особенности параллельной реализации алгоритма ===

=== Масштабируемость алгоритма и его реализации ===

==== Масштабируемость алгоритма ====
==== Масштабируемость реализации алгоритма ====

=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===

=== Существующие реализации алгоритма ===
* [http://projects.jasmeet.me/2013/03/HardCMeans.html Последовательная реализация алгоритма на MatLab]
* [https://github.com/artpar/Hard-Clustering-implementation Последовательная реализация алгоритма на С++]

== Литература ==
<references />

Участник:Каледа Александр/Строгий алгоритм С средних (Hard C-Means)

2016-11-01T11:10:27Z

Каледа Александр:

{{algorithm
| name = Строгий алгоритм С средних (Hard C-Means)
| serial_complexity = <math>O(n)</math>
| pf_height = <math>O(1)</math>
| pf_width = <math>O(n)</math>
| input_data = <math>nm+1</math>
| output_data = <math>(n+m)C</math>
}}

Авторы описания: [[Участник:Каледа_Александр|Каледа Александр]] (разделы [[#Общее описание алгоритма|1.1]], [[#Схема реализации последовательного алгоритма|1.5]], [[#Последовательная сложность алгоритма|1.6]], [[#Информационный граф|1.7]], [[#Ресурс параллелизма алгоритма|1.8]], [[#Входные и выходные данные алгоритма|1.9]]), [[Участник:Шапулин_Андрей|Шапулин Андрей]] (разделы [[#Математическое описание алгоритма|1.2]], [[#Вычислительное ядро алгоритма|1.3]], [[#Макроструктура алгоритма|1.4]], [[#Информационный граф|1.7]], [[#Свойства алгоритма|1.10]], [[#Существующие реализации алгоритма|2.7]]).

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===
'''Строгий алгоритм C средних''' ('''''Hard C-Means, HCM'''''; ''Jang, Sun and Mizutani, 1997'') один из наиболее широко используемых алгоритмов кластеризации данных<ref>[http://faculty.petra.ac.id/resmana/private/fuzzy/nfmod.pdf Jantzen J. Neurofuzzy Modelling. 1998. Электронное издание. 28 Стр.]</ref>. Алгоритм разбивает большие наборы векторов в многомерном пространстве по заранее заданному количеству кластеров (т.е. является управляемым).

На вход алгоритму подается набор векторов и количество кластеров. Дополнительно может задаваться пороговая величина объектной функции, при достижении которой алгоритм останавливается. После окончания работы алгоритма каждый вектор будет отнесет к определенному кластерному центру. Алгоритм, являясь итерационным, зависит от начальных значений кластерных центров, а следовательно может не сходиться к локальному минимуму.

На первом шаге алгоритма происходит инициализация кластерным центров, это можно сделать выбрав случайным образом вектора из входного набора. На следующем шаге начинается итерационный процесс, завершающийся при достижении порогового значения объектной функцией или при минимальном отличии, от значения на предыдущей итерации.

Вычисления, выполняющиеся на очередной итерации алгоритма:

# Расчёт рядовой матрицы (сопоставление вектора соответствующему кластерному центру).
# Расчёт объектной функции.
# Пересчёт кластерных центров.

=== Математическое описание алгоритма ===
Исходные данные: матрица <math>U\in \mathbb{R}^{n\times m}</math>, представляющая собой набор векторов <math>\{u_i\}_{i=1}^{n}, u_i \in \mathbb{R}^m</math>; количество кластеров <math>C \in \mathbb{N}</math>.

Вычисляемые данные: набор векторов - кластерных центров <math>\{c_i\}_{i=1}^{C}, c_i \in \mathbb{R}^m</math>; матрица <math>M\in \mathbb{N}^{n\times C}</math> c информацией о разбиении объектов на кластера. Элемент <math>m_{ij}=1</math>, если <math>u_j \in C_i</math>, где <math>C_i</math> содержит все объекты <math>u</math>, принадлежащие кластеру <math>i</math>. Остальные элементы <math>m_{ij}=0</math>.

Алгоритм:

Шаг 1. Инициализация кластерных центров <math>c_i, i = 1, 2, \dots, C.</math> Это можно сделать выбрав случайным образом C векторов из входного набора <math>\{u_i\}_{i=1}^{n}</math>

Шаг 2. Вычисление рядовой матрицы M.

Матрица <math>M</math> состоит из элементов <math>M = \|m_{ik}\|</math>.

:<math>
m_{ik} = \begin{cases}
1, & \|u_k-c_i\|^2 \leqslant \|u_k-c_j\|^2 \;\; \text{for all } i \neq j; \;\; (i,j=1,2,\ldots,C; \; k = 1,2,\ldots,n)\\
0, & \text{otherwise}.
\end{cases}
</math>

Шаг 3. Расчет объектной функции:

:<math>
J = \sum\limits_{i=1}^C J_i = \sum\limits_{i=1}^C \left( \sum\limits_{k:\, u_k \in C_i} \|u_k -c_i \|^2 \right)</math>.

На этом шаге происходит остановка и выход из цикла, если полученное значение ниже пороговой величины или полученное значение не сильно отличается от значений, полученных на предыдущих циклах.

Шаг 4. Пересчет кластерных центров.

Пересчет кластерных центров выполняется в соответствии со следующим уравнением:
:<math>
c_i = \frac{1}{|C_i|} \sum\limits_{k:\, u_k \in C_i} u_k,
</math>
где <math>|C_i|</math> -- количество элементов в <math>i</math>-ом кластере.

Шаг 5. Переход на шаг 2.

Описание взято из <ref>[http://it-claim.ru/Persons/Neyskiy/Article2_Neiskiy.pdf Нейский И.М. Классификация и сравнение методов кластеризации // Интеллектуальные технологии и системы. Сборник учебно-методических работ и статей аспирантов и студентов. – М.: НОК «CLAIM», 2006. – Выпуск 8. – С. 130-142.]</ref>.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма Hard C-Means можно составить из множественных (всего их <math>nC</math>) вычислений квадратов нормы разности векторов <math>u_k</math> и кластерных центров <math>c_i</math>: <math>\|u_k-c_i\|^2</math>.

=== Макроструктура алгоритма ===
Как записано и в описании ядра алгоритма, основную часть метода составляют множественные (<math>Cn</math>) вычисления квадратов норм:

:<math>\|u_k-c_i\|^2</math>.

Также присутствуют данные вычислительные операции:

* Суммирование квадратов норм векторов:

:<math>
J = \sum\limits_{i=1}^C J_i = \sum\limits_{i=1}^C \left( \sum\limits_{k:\, u_k \in C_i} \|u_k -c_i \|^2 \right)
</math>

* Поэлементное суммирование векторов:

:<math>
c_i = \frac{1}{|C_i|} \sum\limits_{k:\, u_k \in C_i} u_k
</math>

=== Схема реализации последовательного алгоритма ===
Итерационный блок алгоритма можно описать на языке Python следующим образом:

<source lang="python3">
for i in range(n):
idx_min = 0
dist_min = ((u[i] - c[0]) ** 2).sum()

for j in range(1, C):
dist = ((u[i] - c[j]) ** 2).sum()
if dist < dist_min:
idx_min = j
dist_min = dist

M[i, idx_min] = 1
c_next[idx_min] += u[i]
c_next_cnt[idx_min] += 1
J += dist_min
</source>

=== Последовательная сложность алгоритма ===
Предполагаем, что предельная точность алгоритма достигаема менее, чем за <math>n</math> итераций. Иначе использование алгоритма можно считать нерациональным. Также предположим, что размерность <math>m</math> и количество кластерных центров <math>C</math> существенно меньше <math>n</math>.

Операция вычисления квадрата нормы разности векторов требует выполнения <math>m-1</math> арифметических операций сложения, <math>m</math> операций вычитания и <math>m</math> операций умножения.

Каждая итерация алгоритма требует выполнения:
* <math>nC</math> операций вычисления квадрата нормы разности векторов;
* <math>nC</math> операций сравнения квадрата нормы;
* <math>3n</math> операций сложения;

Таким образом, на каждой итерации имеем:
* <math>mnC</math> операций умножения;
* <math>(2mC + 3)n</math> арифметических операций сложения и вычитания;

В итоге имеем сложность последовательной реализации алгоритма <math>O(n)</math>.

=== Информационный граф ===
Граф алгоритма состоит из 4 видов вершин:

'''Первая''' группа вершин отмечена символом '''''M'''''. Ей соответствует вычисление минимального расстояния до кластерных центров, а также запись единицы в соответствующий столбец матрицы, обозначающей принадлежность кластерному центру:
* независимое вычисление расстояний от заданного элемента <math>u_i</math> до каждого из кластерных центров;
* последовательное сравнение полученных значений с целью отыскания максимума;
* операция записи 1 в соответствующий столбец матрицы принадлежности кластерным центрам;

'''Вторая''' вершина отмечена символом '''''J''''', на этом этапе происходит итоговый расчёт объектной функции.

'''Третья''' вершина помечена '''''if''''', на этом этапе происходит проверка условия достижения требуемой точности.

'''Четвертая''' соответствует операции пересчёта кластерных центров, она отмечена как '''''C'''''.

[[File:Cmeans.png|thumb|800px|center|Рисунок 1. Информационный граф алгоритма. Здесь '''''in''''' — ввод входных данных, '''''D''''' — вычисление минимального расстояния до кластерных центров и проставление принадлежности соответствующему кластерному центру, '''''J''''' — вычисление объектной функции по результатам полученных вычислений, '''''if''''' — проверка условия достижения желаемой точности, '''''C''''' — пересчёт кластерных центров и '''''out''''' — вывод полученных данных.]]

=== Ресурс параллелизма алгоритма ===
Основной ресурс параллелизма алгоритма составляет итерационный блок. Эта последовательность итераций может быть выполнена для каждого входного вектора <math>u_i</math> независимо. Однако, в конце выполнения каждого итерационного блока имеют место последовательные вычисления - сложение значений объектной функции, полученных независимо на каждом процессоре, а также перерасчет кластерных центров.

Высота [[глоссарий#Ярусно-параллельная форма графа алгоритма|ЯПФ]] оценивается как <math>O(1)</math> (при условии, что число итераций существенно меньше объёма выборки <math>n</math>). Ширина [[глоссарий#Ярусно-параллельная форма графа алгоритма|ЯПФ]] равна <math>n</math>.

Необходимо учитывать, что при небольшом объеме входной выборки, параллельная реализация алгоритма может лишь понизить производительность. В первую очередь это связано с пересылкой данных для вычисления итоговых значений объектной функции и кластерных центров.

=== Входные и выходные данные алгоритма ===
'''Входные данные:''' матрица <math>U\in \mathbb{R}^{n\times m}</math>, представляющая собой набор векторов <math>\{u_i\}_{i=1}^{n}, u_i \in \mathbb{R}^m</math>; количество кластеров <math>C \in \mathbb{N}</math>.

'''Объём входных данных:''' <math>nm+1</math>.

'''Выходные данные:''' набор векторов - кластерных центров <math>\{c_i\}_{i=1}^{C}, c_i \in \mathbb{R}^m</math>; матрица <math>M\in \mathbb{N}^{n\times C}</math> c информацией о разбиении объектов на кластера. Элемент <math>m_{ij}=1</math>, если <math>u_j \in C_i</math>, где <math>C_i</math> содержит все объекты <math>u</math>, принадлежащие кластеру <math>i</math>. Остальные элементы <math>m_{ij}=0</math>.

'''Объём выходных данных:''' <math>(n+m)C</math>.

=== Свойства алгоритма ===
Достоинства:

* лёгкость реализации;
* вычислительная простота;
* может служить для кластеризации больших наборов числовых данных;

Недостатки:

* задание количества кластеров;
* отсутствие гарантии в нахождении оптимального решения;

Соотношение последовательной и параллельной сложности алгоритма: линейное.

Вычислительная мощность алгоритма, как отношение числа операций к суммарному объему входных и выходных данных равна константе.

Алгоритм является недетерминированным, т.к. он является итерационным с выходом по точности, а также использует датчик случайных чисел для инициализации кластерных центров.

== Программная реализация алгоритма ==

=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
==== Локальность реализации алгоритма ====
===== Структура обращений в память и качественная оценка локальности =====
===== Количественная оценка локальности =====
=== Возможные способы и особенности параллельной реализации алгоритма ===

=== Масштабируемость алгоритма и его реализации ===

==== Масштабируемость алгоритма ====
==== Масштабируемость реализации алгоритма ====

=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===

=== Существующие реализации алгоритма ===
* [http://projects.jasmeet.me/2013/03/HardCMeans.html Последовательная реализация алгоритма на MatLab]
* [https://github.com/artpar/Hard-Clustering-implementation Последовательная реализация алгоритма на С++]

== Литература ==
<references />

Участник:Каледа Александр/Строгий алгоритм С средних (Hard C-Means)

2016-11-01T11:01:30Z

Каледа Александр: /* Математическое описание алгоритма */

{{algorithm
| name = Строгий алгоритм С средних (Hard C-Means)
| serial_complexity = <math>O(n)</math>
| pf_height = <math>O(1)</math>
| pf_width = <math>O(n)</math>
| input_data = <math>nm+1</math>
| output_data = <math>(n+m)C</math>
}}

Авторы описания: [[Участник:Каледа_Александр|Каледа Александр]], [[Участник:Шапулин_Андрей|Шапулин Андрей]].

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===
'''Строгий алгоритм C средних''' ('''''Hard C-Means, HCM'''''; ''Jang, Sun and Mizutani, 1997'') один из наиболее широко используемых алгоритмов кластеризации данных<ref>[http://faculty.petra.ac.id/resmana/private/fuzzy/nfmod.pdf Jantzen J. Neurofuzzy Modelling. 1998. Электронное издание. 28 Стр.]</ref>. Алгоритм разбивает большие наборы векторов в многомерном пространстве по заранее заданному количеству кластеров (т.е. является управляемым).

На вход алгоритму подается набор векторов и количество кластеров. Дополнительно может задаваться пороговая величина объектной функции, при достижении которой алгоритм останавливается. После окончания работы алгоритма каждый вектор будет отнесет к определенному кластерному центру. Алгоритм, являясь итерационным, зависит от начальных значений кластерных центров, а следовательно может не сходиться к локальному минимуму.

На первом шаге алгоритма происходит инициализация кластерным центров, это можно сделать выбрав случайным образом вектора из входного набора. На следующем шаге начинается итерационный процесс, завершающийся при достижении порогового значения объектной функцией или при минимальном отличии, от значения на предыдущей итерации.

Вычисления, выполняющиеся на очередной итерации алгоритма:

# Расчёт рядовой матрицы (сопоставление вектора соответствующему кластерному центру).
# Расчёт объектной функции.
# Пересчёт кластерных центров.

=== Математическое описание алгоритма ===
Исходные данные: матрица <math>U\in \mathbb{R}^{n\times m}</math>, представляющая собой набор векторов <math>\{u_i\}_{i=1}^{n}, u_i \in \mathbb{R}^m</math>; количество кластеров <math>C \in \mathbb{N}</math>.

Вычисляемые данные: набор векторов - кластерных центров <math>\{c_i\}_{i=1}^{C}, c_i \in \mathbb{R}^m</math>; матрица <math>M\in \mathbb{N}^{n\times C}</math> c информацией о разбиении объектов на кластера. Элемент <math>m_{ij}=1</math>, если <math>u_j \in C_i</math>, где <math>C_i</math> содержит все объекты <math>u</math>, принадлежащие кластеру <math>i</math>. Остальные элементы <math>m_{ij}=0</math>.

Алгоритм:

Шаг 1. Инициализация кластерных центров <math>c_i, i = 1, 2, \dots, C.</math> Это можно сделать выбрав случайным образом C векторов из входного набора <math>\{u_i\}_{i=1}^{n}</math>

Шаг 2. Вычисление рядовой матрицы M.

Матрица <math>M</math> состоит из элементов <math>M = \|m_{ik}\|</math>.

:<math>
m_{ik} = \begin{cases}
1, & \|u_k-c_i\|^2 \leqslant \|u_k-c_j\|^2 \;\; \text{for all } i \neq j; \;\; (i,j=1,2,\ldots,C; \; k = 1,2,\ldots,n)\\
0, & \text{otherwise}.
\end{cases}
</math>

Шаг 3. Расчет объектной функции:

:<math>
J = \sum\limits_{i=1}^C J_i = \sum\limits_{i=1}^C \left( \sum\limits_{k:\, u_k \in C_i} \|u_k -c_i \|^2 \right)</math>.

На этом шаге происходит остановка и выход из цикла, если полученное значение ниже пороговой величины или полученное значение не сильно отличается от значений, полученных на предыдущих циклах.

Шаг 4. Пересчет кластерных центров.

Пересчет кластерных центров выполняется в соответствии со следующим уравнением:
:<math>
c_i = \frac{1}{|C_i|} \sum\limits_{k:\, u_k \in C_i} u_k,
</math>
где <math>|C_i|</math> -- количество элементов в <math>i</math>-ом кластере.

Шаг 5. Переход на шаг 2.

Описание взято из <ref>[http://it-claim.ru/Persons/Neyskiy/Article2_Neiskiy.pdf Нейский И.М. Классификация и сравнение методов кластеризации // Интеллектуальные технологии и системы. Сборник учебно-методических работ и статей аспирантов и студентов. – М.: НОК «CLAIM», 2006. – Выпуск 8. – С. 130-142.]</ref>.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма Hard C-Means можно составить из множественных (всего их <math>nC</math>) вычислений квадратов нормы разности векторов <math>u_k</math> и кластерных центров <math>c_i</math>: <math>\|u_k-c_i\|^2</math>.

=== Макроструктура алгоритма ===
Как записано и в описании ядра алгоритма, основную часть метода составляют множественные (<math>Cn</math>) вычисления квадратов норм:

:<math>\|u_k-c_i\|^2</math>.

Также присутствуют данные вычислительные операции:

* Суммирование квадратов норм векторов:

:<math>
J = \sum\limits_{i=1}^C J_i = \sum\limits_{i=1}^C \left( \sum\limits_{k:\, u_k \in C_i} \|u_k -c_i \|^2 \right)
</math>

* Поэлементное суммирование векторов:

:<math>
c_i = \frac{1}{|C_i|} \sum\limits_{k:\, u_k \in C_i} u_k
</math>

=== Схема реализации последовательного алгоритма ===
Итерационный блок алгоритма можно описать на языке Python следующим образом:

<source lang="python3">
for i in range(n):
idx_min = 0
dist_min = ((u[i] - c[0]) ** 2).sum()

for j in range(1, C):
dist = ((u[i] - c[j]) ** 2).sum()
if dist < dist_min:
idx_min = j
dist_min = dist

M[i, idx_min] = 1
c_next[idx_min] += u[i]
c_next_cnt[idx_min] += 1
J += dist_min
</source>

=== Последовательная сложность алгоритма ===
Предполагаем, что предельная точность алгоритма достигаема менее, чем за <math>n</math> итераций. Иначе использование алгоритма можно считать нерациональным. Также предположим, что размерность <math>m</math> и количество кластерных центров <math>C</math> существенно меньше <math>n</math>.

Операция вычисления квадрата нормы разности векторов требует выполнения <math>m-1</math> арифметических операций сложения, <math>m</math> операций вычитания и <math>m</math> операций умножения.

Каждая итерация алгоритма требует выполнения:
* <math>nC</math> операций вычисления квадрата нормы разности векторов;
* <math>nC</math> операций сравнения квадрата нормы;
* <math>3n</math> операций сложения;

Таким образом, на каждой итерации имеем:
* <math>mnC</math> операций умножения;
* <math>(2mC + 3)n</math> арифметических операций сложения и вычитания;

В итоге имеем сложность последовательной реализации алгоритма <math>O(n)</math>.

=== Информационный граф ===
Граф алгоритма состоит из 4 видов вершин:

'''Первая''' группа вершин отмечена символом '''''M'''''. Ей соответствует вычисление минимального расстояния до кластерных центров, а также запись единицы в соответствующий столбец матрицы, обозначающей принадлежность кластерному центру:
* независимое вычисление расстояний от заданного элемента <math>u_i</math> до каждого из кластерных центров;
* последовательное сравнение полученных значений с целью отыскания максимума;
* операция записи 1 в соответствующий столбец матрицы принадлежности кластерным центрам;

'''Вторая''' вершина отмечена символом '''''J''''', на этом этапе происходит итоговый расчёт объектной функции.

'''Третья''' вершина помечена '''''if''''', на этом этапе происходит проверка условия достижения требуемой точности.

'''Четвертая''' соответствует операции пересчёта кластерных центров, она отмечена как '''''C'''''.

[[File:Cmeans.png|thumb|800px|center|Рисунок 1. Информационный граф алгоритма. Здесь '''''in''''' — ввод входных данных, '''''D''''' — вычисление минимального расстояния до кластерных центров и проставление принадлежности соответствующему кластерному центру, '''''J''''' — вычисление объектной функции по результатам полученных вычислений, '''''if''''' — проверка условия достижения желаемой точности, '''''C''''' — пересчёт кластерных центров и '''''out''''' — вывод полученных данных.]]

=== Ресурс параллелизма алгоритма ===
Основной ресурс параллелизма алгоритма составляет итерационный блок. Эта последовательность итераций может быть выполнена для каждого входного вектора <math>u_i</math> независимо. Однако, в конце выполнения каждого итерационного блока имеют место последовательные вычисления - сложение значений объектной функции, полученных независимо на каждом процессоре, а также перерасчет кластерных центров.

Высота [[глоссарий#Ярусно-параллельная форма графа алгоритма|ЯПФ]] оценивается как <math>O(1)</math> (при условии, что число итераций существенно меньше объёма выборки <math>n</math>). Ширина [[глоссарий#Ярусно-параллельная форма графа алгоритма|ЯПФ]] равна <math>n</math>.

Необходимо учитывать, что при небольшом объеме входной выборки, параллельная реализация алгоритма может лишь понизить производительность. В первую очередь это связано с пересылкой данных для вычисления итоговых значений объектной функции и кластерных центров.

=== Входные и выходные данные алгоритма ===
'''Входные данные:''' матрица <math>U\in \mathbb{R}^{n\times m}</math>, представляющая собой набор векторов <math>\{u_i\}_{i=1}^{n}, u_i \in \mathbb{R}^m</math>; количество кластеров <math>C \in \mathbb{N}</math>.

'''Объём входных данных:''' <math>nm+1</math>.

'''Выходные данные:''' набор векторов - кластерных центров <math>\{c_i\}_{i=1}^{C}, c_i \in \mathbb{R}^m</math>; матрица <math>M\in \mathbb{N}^{n\times C}</math> c информацией о разбиении объектов на кластера. Элемент <math>m_{ij}=1</math>, если <math>u_j \in C_i</math>, где <math>C_i</math> содержит все объекты <math>u</math>, принадлежащие кластеру <math>i</math>. Остальные элементы <math>m_{ij}=0</math>.

'''Объём выходных данных:''' <math>(n+m)C</math>.

=== Свойства алгоритма ===
Достоинства:

* лёгкость реализации;
* вычислительная простота;
* может служить для кластеризации больших наборов числовых данных;

Недостатки:

* задание количества кластеров;
* отсутствие гарантии в нахождении оптимального решения;

Соотношение последовательной и параллельной сложности алгоритма: линейное.

Вычислительная мощность алгоритма, как отношение числа операций к суммарному объему входных и выходных данных равна константе.

Алгоритм является недетерминированным, т.к. он является итерационным с выходом по точности, а также использует датчик случайных чисел для инициализации кластерных центров.

== Программная реализация алгоритма ==

=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
==== Локальность реализации алгоритма ====
===== Структура обращений в память и качественная оценка локальности =====
===== Количественная оценка локальности =====
=== Возможные способы и особенности параллельной реализации алгоритма ===

=== Масштабируемость алгоритма и его реализации ===

==== Масштабируемость алгоритма ====
==== Масштабируемость реализации алгоритма ====

=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===

=== Существующие реализации алгоритма ===
* [http://projects.jasmeet.me/2013/03/HardCMeans.html Последовательная реализация алгоритма на MatLab]
* [https://github.com/artpar/Hard-Clustering-implementation Последовательная реализация алгоритма на С++]

== Литература ==
<references />

Участник:Каледа Александр/Строгий алгоритм С средних (Hard C-Means)

2016-11-01T11:00:40Z

Каледа Александр: /* Общее описание алгоритма */

{{algorithm
| name = Строгий алгоритм С средних (Hard C-Means)
| serial_complexity = <math>O(n)</math>
| pf_height = <math>O(1)</math>
| pf_width = <math>O(n)</math>
| input_data = <math>nm+1</math>
| output_data = <math>(n+m)C</math>
}}

Авторы описания: [[Участник:Каледа_Александр|Каледа Александр]], [[Участник:Шапулин_Андрей|Шапулин Андрей]].

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===
'''Строгий алгоритм C средних''' ('''''Hard C-Means, HCM'''''; ''Jang, Sun and Mizutani, 1997'') один из наиболее широко используемых алгоритмов кластеризации данных<ref>[http://faculty.petra.ac.id/resmana/private/fuzzy/nfmod.pdf Jantzen J. Neurofuzzy Modelling. 1998. Электронное издание. 28 Стр.]</ref>. Алгоритм разбивает большие наборы векторов в многомерном пространстве по заранее заданному количеству кластеров (т.е. является управляемым).

На вход алгоритму подается набор векторов и количество кластеров. Дополнительно может задаваться пороговая величина объектной функции, при достижении которой алгоритм останавливается. После окончания работы алгоритма каждый вектор будет отнесет к определенному кластерному центру. Алгоритм, являясь итерационным, зависит от начальных значений кластерных центров, а следовательно может не сходиться к локальному минимуму.

На первом шаге алгоритма происходит инициализация кластерным центров, это можно сделать выбрав случайным образом вектора из входного набора. На следующем шаге начинается итерационный процесс, завершающийся при достижении порогового значения объектной функцией или при минимальном отличии, от значения на предыдущей итерации.

Вычисления, выполняющиеся на очередной итерации алгоритма:

# Расчёт рядовой матрицы (сопоставление вектора соответствующему кластерному центру).
# Расчёт объектной функции.
# Пересчёт кластерных центров.

=== Математическое описание алгоритма ===
Исходные данные: матрица <math>U\in \mathbb{R}^{n\times m}</math>, представляющая собой набор векторов <math>\{u_i\}_{i=1}^{n}, u_i \in \mathbb{R}^m</math>; количество кластеров <math>C \in \mathbb{N}</math>.

Вычисляемые данные: набор векторов - кластерных центров <math>\{c_i\}_{i=1}^{C}, c_i \in \mathbb{R}^m</math>; матрица <math>M\in \mathbb{N}^{n\times C}</math> c информацией о разбиении объектов на кластера. Элемент <math>m_{ij}=1</math>, если <math>u_j \in C_i</math>, где <math>C_i</math> содержит все объекты <math>u</math>, принадлежащие кластеру <math>i</math>. Остальные элементы <math>m_{ij}=0</math>.

Алгоритм:

Шаг 1. Инициализация кластерных центров <math>c_i, i = 1, 2, \dots, C.</math> Это можно сделать выбрав случайным образом C векторов из входного набора <math>\{u_i\}_{i=1}^{n}</math>

Шаг 2. Вычисление рядовой матрицы M.

Матрица <math>M</math> состоит из элементов <math>M = \|m_{ik}\|</math>.

:<math>
m_{ik} = \begin{cases}
1, & \|u_k-c_i\|^2 \leqslant \|u_k-c_j\|^2 \;\; \text{for all } i \neq j; \;\; (i,j=1,2,\ldots,C; \; k = 1,2,\ldots,n)\\
0, & \text{otherwise}.
\end{cases}
</math>

Шаг 3. Расчет объектной функции:

:<math>
J = \sum\limits_{i=1}^C J_i = \sum\limits_{i=1}^C \left( \sum\limits_{k:\, u_k \in C_i} \|u_k -c_i \|^2 \right)</math>.

На этом шаге происходит остановка и выход из цикла, если полученное значение ниже пороговой величины или полученное значение не сильно отличается от значений, полученных на предыдущих циклах.

Шаг 4. Пересчет кластерных центров.

Пересчет кластерных центров выполняется в соответствии со следующим уравнением:
:<math>
c_i = \frac{1}{|C_i|} \sum\limits_{k:\, u_k \in C_i} u_k,
</math>
где <math>|C_i|</math> -- количество элементов в <math>i</math>-ом кластере.

Шаг 5. Переход на шаг 2.

Описание взято из <ref>Нейский И.М. Классификация и сравнение методов кластеризации // Интеллектуальные технологии и системы. Сборник учебно-методических работ и статей аспирантов и студентов. – М.: НОК «CLAIM», 2006. – Выпуск 8. – С. 130-142.</ref>.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма Hard C-Means можно составить из множественных (всего их <math>nC</math>) вычислений квадратов нормы разности векторов <math>u_k</math> и кластерных центров <math>c_i</math>: <math>\|u_k-c_i\|^2</math>.

=== Макроструктура алгоритма ===
Как записано и в описании ядра алгоритма, основную часть метода составляют множественные (<math>Cn</math>) вычисления квадратов норм:

:<math>\|u_k-c_i\|^2</math>.

Также присутствуют данные вычислительные операции:

* Суммирование квадратов норм векторов:

:<math>
J = \sum\limits_{i=1}^C J_i = \sum\limits_{i=1}^C \left( \sum\limits_{k:\, u_k \in C_i} \|u_k -c_i \|^2 \right)
</math>

* Поэлементное суммирование векторов:

:<math>
c_i = \frac{1}{|C_i|} \sum\limits_{k:\, u_k \in C_i} u_k
</math>

=== Схема реализации последовательного алгоритма ===
Итерационный блок алгоритма можно описать на языке Python следующим образом:

<source lang="python3">
for i in range(n):
idx_min = 0
dist_min = ((u[i] - c[0]) ** 2).sum()

for j in range(1, C):
dist = ((u[i] - c[j]) ** 2).sum()
if dist < dist_min:
idx_min = j
dist_min = dist

M[i, idx_min] = 1
c_next[idx_min] += u[i]
c_next_cnt[idx_min] += 1
J += dist_min
</source>

=== Последовательная сложность алгоритма ===
Предполагаем, что предельная точность алгоритма достигаема менее, чем за <math>n</math> итераций. Иначе использование алгоритма можно считать нерациональным. Также предположим, что размерность <math>m</math> и количество кластерных центров <math>C</math> существенно меньше <math>n</math>.

Операция вычисления квадрата нормы разности векторов требует выполнения <math>m-1</math> арифметических операций сложения, <math>m</math> операций вычитания и <math>m</math> операций умножения.

Каждая итерация алгоритма требует выполнения:
* <math>nC</math> операций вычисления квадрата нормы разности векторов;
* <math>nC</math> операций сравнения квадрата нормы;
* <math>3n</math> операций сложения;

Таким образом, на каждой итерации имеем:
* <math>mnC</math> операций умножения;
* <math>(2mC + 3)n</math> арифметических операций сложения и вычитания;

В итоге имеем сложность последовательной реализации алгоритма <math>O(n)</math>.

=== Информационный граф ===
Граф алгоритма состоит из 4 видов вершин:

'''Первая''' группа вершин отмечена символом '''''M'''''. Ей соответствует вычисление минимального расстояния до кластерных центров, а также запись единицы в соответствующий столбец матрицы, обозначающей принадлежность кластерному центру:
* независимое вычисление расстояний от заданного элемента <math>u_i</math> до каждого из кластерных центров;
* последовательное сравнение полученных значений с целью отыскания максимума;
* операция записи 1 в соответствующий столбец матрицы принадлежности кластерным центрам;

'''Вторая''' вершина отмечена символом '''''J''''', на этом этапе происходит итоговый расчёт объектной функции.

'''Третья''' вершина помечена '''''if''''', на этом этапе происходит проверка условия достижения требуемой точности.

'''Четвертая''' соответствует операции пересчёта кластерных центров, она отмечена как '''''C'''''.

[[File:Cmeans.png|thumb|800px|center|Рисунок 1. Информационный граф алгоритма. Здесь '''''in''''' — ввод входных данных, '''''D''''' — вычисление минимального расстояния до кластерных центров и проставление принадлежности соответствующему кластерному центру, '''''J''''' — вычисление объектной функции по результатам полученных вычислений, '''''if''''' — проверка условия достижения желаемой точности, '''''C''''' — пересчёт кластерных центров и '''''out''''' — вывод полученных данных.]]

=== Ресурс параллелизма алгоритма ===
Основной ресурс параллелизма алгоритма составляет итерационный блок. Эта последовательность итераций может быть выполнена для каждого входного вектора <math>u_i</math> независимо. Однако, в конце выполнения каждого итерационного блока имеют место последовательные вычисления - сложение значений объектной функции, полученных независимо на каждом процессоре, а также перерасчет кластерных центров.

Высота [[глоссарий#Ярусно-параллельная форма графа алгоритма|ЯПФ]] оценивается как <math>O(1)</math> (при условии, что число итераций существенно меньше объёма выборки <math>n</math>). Ширина [[глоссарий#Ярусно-параллельная форма графа алгоритма|ЯПФ]] равна <math>n</math>.

Необходимо учитывать, что при небольшом объеме входной выборки, параллельная реализация алгоритма может лишь понизить производительность. В первую очередь это связано с пересылкой данных для вычисления итоговых значений объектной функции и кластерных центров.

=== Входные и выходные данные алгоритма ===
'''Входные данные:''' матрица <math>U\in \mathbb{R}^{n\times m}</math>, представляющая собой набор векторов <math>\{u_i\}_{i=1}^{n}, u_i \in \mathbb{R}^m</math>; количество кластеров <math>C \in \mathbb{N}</math>.

'''Объём входных данных:''' <math>nm+1</math>.

'''Выходные данные:''' набор векторов - кластерных центров <math>\{c_i\}_{i=1}^{C}, c_i \in \mathbb{R}^m</math>; матрица <math>M\in \mathbb{N}^{n\times C}</math> c информацией о разбиении объектов на кластера. Элемент <math>m_{ij}=1</math>, если <math>u_j \in C_i</math>, где <math>C_i</math> содержит все объекты <math>u</math>, принадлежащие кластеру <math>i</math>. Остальные элементы <math>m_{ij}=0</math>.

'''Объём выходных данных:''' <math>(n+m)C</math>.

=== Свойства алгоритма ===
Достоинства:

* лёгкость реализации;
* вычислительная простота;
* может служить для кластеризации больших наборов числовых данных;

Недостатки:

* задание количества кластеров;
* отсутствие гарантии в нахождении оптимального решения;

Соотношение последовательной и параллельной сложности алгоритма: линейное.

Вычислительная мощность алгоритма, как отношение числа операций к суммарному объему входных и выходных данных равна константе.

Алгоритм является недетерминированным, т.к. он является итерационным с выходом по точности, а также использует датчик случайных чисел для инициализации кластерных центров.

== Программная реализация алгоритма ==

=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
==== Локальность реализации алгоритма ====
===== Структура обращений в память и качественная оценка локальности =====
===== Количественная оценка локальности =====
=== Возможные способы и особенности параллельной реализации алгоритма ===

=== Масштабируемость алгоритма и его реализации ===

==== Масштабируемость алгоритма ====
==== Масштабируемость реализации алгоритма ====

=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===

=== Существующие реализации алгоритма ===
* [http://projects.jasmeet.me/2013/03/HardCMeans.html Последовательная реализация алгоритма на MatLab]
* [https://github.com/artpar/Hard-Clustering-implementation Последовательная реализация алгоритма на С++]

== Литература ==
<references />

Участник:Каледа Александр/Строгий алгоритм С средних (Hard C-Means)

2016-11-01T11:00:08Z

Каледа Александр: /* Общее описание алгоритма */

{{algorithm
| name = Строгий алгоритм С средних (Hard C-Means)
| serial_complexity = <math>O(n)</math>
| pf_height = <math>O(1)</math>
| pf_width = <math>O(n)</math>
| input_data = <math>nm+1</math>
| output_data = <math>(n+m)C</math>
}}

Авторы описания: [[Участник:Каледа_Александр|Каледа Александр]], [[Участник:Шапулин_Андрей|Шапулин Андрей]].

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===
'''Строгий алгоритм C средних''' ('''''Hard C-Means, HCM'''''; ''Jang, Sun and Mizutani, 1997'') один из наиболее широко используемых алгоритмов кластеризации данных<ref>http://faculty.petra.ac.id/resmana/private/fuzzy/nfmod.pdf Jantzen J. Neurofuzzy Modelling. 1998. Электронное издание. 28 Стр.]</ref>. Алгоритм разбивает большие наборы векторов в многомерном пространстве по заранее заданному количеству кластеров (т.е. является управляемым).

На вход алгоритму подается набор векторов и количество кластеров. Дополнительно может задаваться пороговая величина объектной функции, при достижении которой алгоритм останавливается. После окончания работы алгоритма каждый вектор будет отнесет к определенному кластерному центру. Алгоритм, являясь итерационным, зависит от начальных значений кластерных центров, а следовательно может не сходиться к локальному минимуму.

На первом шаге алгоритма происходит инициализация кластерным центров, это можно сделать выбрав случайным образом вектора из входного набора. На следующем шаге начинается итерационный процесс, завершающийся при достижении порогового значения объектной функцией или при минимальном отличии, от значения на предыдущей итерации.

Вычисления, выполняющиеся на очередной итерации алгоритма:

# Расчёт рядовой матрицы (сопоставление вектора соответствующему кластерному центру).
# Расчёт объектной функции.
# Пересчёт кластерных центров.

=== Математическое описание алгоритма ===
Исходные данные: матрица <math>U\in \mathbb{R}^{n\times m}</math>, представляющая собой набор векторов <math>\{u_i\}_{i=1}^{n}, u_i \in \mathbb{R}^m</math>; количество кластеров <math>C \in \mathbb{N}</math>.

Вычисляемые данные: набор векторов - кластерных центров <math>\{c_i\}_{i=1}^{C}, c_i \in \mathbb{R}^m</math>; матрица <math>M\in \mathbb{N}^{n\times C}</math> c информацией о разбиении объектов на кластера. Элемент <math>m_{ij}=1</math>, если <math>u_j \in C_i</math>, где <math>C_i</math> содержит все объекты <math>u</math>, принадлежащие кластеру <math>i</math>. Остальные элементы <math>m_{ij}=0</math>.

Алгоритм:

Шаг 1. Инициализация кластерных центров <math>c_i, i = 1, 2, \dots, C.</math> Это можно сделать выбрав случайным образом C векторов из входного набора <math>\{u_i\}_{i=1}^{n}</math>

Шаг 2. Вычисление рядовой матрицы M.

Матрица <math>M</math> состоит из элементов <math>M = \|m_{ik}\|</math>.

:<math>
m_{ik} = \begin{cases}
1, & \|u_k-c_i\|^2 \leqslant \|u_k-c_j\|^2 \;\; \text{for all } i \neq j; \;\; (i,j=1,2,\ldots,C; \; k = 1,2,\ldots,n)\\
0, & \text{otherwise}.
\end{cases}
</math>

Шаг 3. Расчет объектной функции:

:<math>
J = \sum\limits_{i=1}^C J_i = \sum\limits_{i=1}^C \left( \sum\limits_{k:\, u_k \in C_i} \|u_k -c_i \|^2 \right)</math>.

На этом шаге происходит остановка и выход из цикла, если полученное значение ниже пороговой величины или полученное значение не сильно отличается от значений, полученных на предыдущих циклах.

Шаг 4. Пересчет кластерных центров.

Пересчет кластерных центров выполняется в соответствии со следующим уравнением:
:<math>
c_i = \frac{1}{|C_i|} \sum\limits_{k:\, u_k \in C_i} u_k,
</math>
где <math>|C_i|</math> -- количество элементов в <math>i</math>-ом кластере.

Шаг 5. Переход на шаг 2.

Описание взято из <ref>Нейский И.М. Классификация и сравнение методов кластеризации // Интеллектуальные технологии и системы. Сборник учебно-методических работ и статей аспирантов и студентов. – М.: НОК «CLAIM», 2006. – Выпуск 8. – С. 130-142.</ref>.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма Hard C-Means можно составить из множественных (всего их <math>nC</math>) вычислений квадратов нормы разности векторов <math>u_k</math> и кластерных центров <math>c_i</math>: <math>\|u_k-c_i\|^2</math>.

=== Макроструктура алгоритма ===
Как записано и в описании ядра алгоритма, основную часть метода составляют множественные (<math>Cn</math>) вычисления квадратов норм:

:<math>\|u_k-c_i\|^2</math>.

Также присутствуют данные вычислительные операции:

* Суммирование квадратов норм векторов:

:<math>
J = \sum\limits_{i=1}^C J_i = \sum\limits_{i=1}^C \left( \sum\limits_{k:\, u_k \in C_i} \|u_k -c_i \|^2 \right)
</math>

* Поэлементное суммирование векторов:

:<math>
c_i = \frac{1}{|C_i|} \sum\limits_{k:\, u_k \in C_i} u_k
</math>

=== Схема реализации последовательного алгоритма ===
Итерационный блок алгоритма можно описать на языке Python следующим образом:

<source lang="python3">
for i in range(n):
idx_min = 0
dist_min = ((u[i] - c[0]) ** 2).sum()

for j in range(1, C):
dist = ((u[i] - c[j]) ** 2).sum()
if dist < dist_min:
idx_min = j
dist_min = dist

M[i, idx_min] = 1
c_next[idx_min] += u[i]
c_next_cnt[idx_min] += 1
J += dist_min
</source>

=== Последовательная сложность алгоритма ===
Предполагаем, что предельная точность алгоритма достигаема менее, чем за <math>n</math> итераций. Иначе использование алгоритма можно считать нерациональным. Также предположим, что размерность <math>m</math> и количество кластерных центров <math>C</math> существенно меньше <math>n</math>.

Операция вычисления квадрата нормы разности векторов требует выполнения <math>m-1</math> арифметических операций сложения, <math>m</math> операций вычитания и <math>m</math> операций умножения.

Каждая итерация алгоритма требует выполнения:
* <math>nC</math> операций вычисления квадрата нормы разности векторов;
* <math>nC</math> операций сравнения квадрата нормы;
* <math>3n</math> операций сложения;

Таким образом, на каждой итерации имеем:
* <math>mnC</math> операций умножения;
* <math>(2mC + 3)n</math> арифметических операций сложения и вычитания;

В итоге имеем сложность последовательной реализации алгоритма <math>O(n)</math>.

=== Информационный граф ===
Граф алгоритма состоит из 4 видов вершин:

'''Первая''' группа вершин отмечена символом '''''M'''''. Ей соответствует вычисление минимального расстояния до кластерных центров, а также запись единицы в соответствующий столбец матрицы, обозначающей принадлежность кластерному центру:
* независимое вычисление расстояний от заданного элемента <math>u_i</math> до каждого из кластерных центров;
* последовательное сравнение полученных значений с целью отыскания максимума;
* операция записи 1 в соответствующий столбец матрицы принадлежности кластерным центрам;

'''Вторая''' вершина отмечена символом '''''J''''', на этом этапе происходит итоговый расчёт объектной функции.

'''Третья''' вершина помечена '''''if''''', на этом этапе происходит проверка условия достижения требуемой точности.

'''Четвертая''' соответствует операции пересчёта кластерных центров, она отмечена как '''''C'''''.

[[File:Cmeans.png|thumb|800px|center|Рисунок 1. Информационный граф алгоритма. Здесь '''''in''''' — ввод входных данных, '''''D''''' — вычисление минимального расстояния до кластерных центров и проставление принадлежности соответствующему кластерному центру, '''''J''''' — вычисление объектной функции по результатам полученных вычислений, '''''if''''' — проверка условия достижения желаемой точности, '''''C''''' — пересчёт кластерных центров и '''''out''''' — вывод полученных данных.]]

=== Ресурс параллелизма алгоритма ===
Основной ресурс параллелизма алгоритма составляет итерационный блок. Эта последовательность итераций может быть выполнена для каждого входного вектора <math>u_i</math> независимо. Однако, в конце выполнения каждого итерационного блока имеют место последовательные вычисления - сложение значений объектной функции, полученных независимо на каждом процессоре, а также перерасчет кластерных центров.

Высота [[глоссарий#Ярусно-параллельная форма графа алгоритма|ЯПФ]] оценивается как <math>O(1)</math> (при условии, что число итераций существенно меньше объёма выборки <math>n</math>). Ширина [[глоссарий#Ярусно-параллельная форма графа алгоритма|ЯПФ]] равна <math>n</math>.

Необходимо учитывать, что при небольшом объеме входной выборки, параллельная реализация алгоритма может лишь понизить производительность. В первую очередь это связано с пересылкой данных для вычисления итоговых значений объектной функции и кластерных центров.

=== Входные и выходные данные алгоритма ===
'''Входные данные:''' матрица <math>U\in \mathbb{R}^{n\times m}</math>, представляющая собой набор векторов <math>\{u_i\}_{i=1}^{n}, u_i \in \mathbb{R}^m</math>; количество кластеров <math>C \in \mathbb{N}</math>.

'''Объём входных данных:''' <math>nm+1</math>.

'''Выходные данные:''' набор векторов - кластерных центров <math>\{c_i\}_{i=1}^{C}, c_i \in \mathbb{R}^m</math>; матрица <math>M\in \mathbb{N}^{n\times C}</math> c информацией о разбиении объектов на кластера. Элемент <math>m_{ij}=1</math>, если <math>u_j \in C_i</math>, где <math>C_i</math> содержит все объекты <math>u</math>, принадлежащие кластеру <math>i</math>. Остальные элементы <math>m_{ij}=0</math>.

'''Объём выходных данных:''' <math>(n+m)C</math>.

=== Свойства алгоритма ===
Достоинства:

* лёгкость реализации;
* вычислительная простота;
* может служить для кластеризации больших наборов числовых данных;

Недостатки:

* задание количества кластеров;
* отсутствие гарантии в нахождении оптимального решения;

Соотношение последовательной и параллельной сложности алгоритма: линейное.

Вычислительная мощность алгоритма, как отношение числа операций к суммарному объему входных и выходных данных равна константе.

Алгоритм является недетерминированным, т.к. он является итерационным с выходом по точности, а также использует датчик случайных чисел для инициализации кластерных центров.

== Программная реализация алгоритма ==

=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
==== Локальность реализации алгоритма ====
===== Структура обращений в память и качественная оценка локальности =====
===== Количественная оценка локальности =====
=== Возможные способы и особенности параллельной реализации алгоритма ===

=== Масштабируемость алгоритма и его реализации ===

==== Масштабируемость алгоритма ====
==== Масштабируемость реализации алгоритма ====

=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===

=== Существующие реализации алгоритма ===
* [http://projects.jasmeet.me/2013/03/HardCMeans.html Последовательная реализация алгоритма на MatLab]
* [https://github.com/artpar/Hard-Clustering-implementation Последовательная реализация алгоритма на С++]

== Литература ==
<references />

Участник:Каледа Александр/Строгий алгоритм С средних (Hard C-Means)

2016-11-01T10:56:24Z

Каледа Александр: /* Общее описание алгоритма */

{{algorithm
| name = Строгий алгоритм С средних (Hard C-Means)
| serial_complexity = <math>O(n)</math>
| pf_height = <math>O(1)</math>
| pf_width = <math>O(n)</math>
| input_data = <math>nm+1</math>
| output_data = <math>(n+m)C</math>
}}

Авторы описания: [[Участник:Каледа_Александр|Каледа Александр]], [[Участник:Шапулин_Андрей|Шапулин Андрей]].

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===
'''Строгий алгоритм C средних''' ('''''Hard C-Means, HCM'''''; ''Jang, Sun and Mizutani, 1997'') один из наиболее широко используемых алгоритмов кластеризации данных<ref>Jantzen J. Neurofuzzy Modelling. 1998. Электронное издание. 28 Стр.</ref>. Алгоритм разбивает большие наборы векторов в многомерном пространстве по заранее заданному количеству кластеров (т.е. является управляемым).

На вход алгоритму подается набор векторов и количество кластеров. Дополнительно может задаваться пороговая величина объектной функции, при достижении которой алгоритм останавливается. После окончания работы алгоритма каждый вектор будет отнесет к определенному кластерному центру. Алгоритм, являясь итерационным, зависит от начальных значений кластерных центров, а следовательно может не сходиться к локальному минимуму.

На первом шаге алгоритма происходит инициализация кластерным центров, это можно сделать выбрав случайным образом вектора из входного набора. На следующем шаге начинается итерационный процесс, завершающийся при достижении порогового значения объектной функцией или при минимальном отличии, от значения на предыдущей итерации.

Вычисления, выполняющиеся на очередной итерации алгоритма:

# Расчёт рядовой матрицы (сопоставление вектора соответствующему кластерному центру).
# Расчёт объектной функции.
# Пересчёт кластерных центров.

=== Математическое описание алгоритма ===
Исходные данные: матрица <math>U\in \mathbb{R}^{n\times m}</math>, представляющая собой набор векторов <math>\{u_i\}_{i=1}^{n}, u_i \in \mathbb{R}^m</math>; количество кластеров <math>C \in \mathbb{N}</math>.

Вычисляемые данные: набор векторов - кластерных центров <math>\{c_i\}_{i=1}^{C}, c_i \in \mathbb{R}^m</math>; матрица <math>M\in \mathbb{N}^{n\times C}</math> c информацией о разбиении объектов на кластера. Элемент <math>m_{ij}=1</math>, если <math>u_j \in C_i</math>, где <math>C_i</math> содержит все объекты <math>u</math>, принадлежащие кластеру <math>i</math>. Остальные элементы <math>m_{ij}=0</math>.

Алгоритм:

Шаг 1. Инициализация кластерных центров <math>c_i, i = 1, 2, \dots, C.</math> Это можно сделать выбрав случайным образом C векторов из входного набора <math>\{u_i\}_{i=1}^{n}</math>

Шаг 2. Вычисление рядовой матрицы M.

Матрица <math>M</math> состоит из элементов <math>M = \|m_{ik}\|</math>.

:<math>
m_{ik} = \begin{cases}
1, & \|u_k-c_i\|^2 \leqslant \|u_k-c_j\|^2 \;\; \text{for all } i \neq j; \;\; (i,j=1,2,\ldots,C; \; k = 1,2,\ldots,n)\\
0, & \text{otherwise}.
\end{cases}
</math>

Шаг 3. Расчет объектной функции:

:<math>
J = \sum\limits_{i=1}^C J_i = \sum\limits_{i=1}^C \left( \sum\limits_{k:\, u_k \in C_i} \|u_k -c_i \|^2 \right)</math>.

На этом шаге происходит остановка и выход из цикла, если полученное значение ниже пороговой величины или полученное значение не сильно отличается от значений, полученных на предыдущих циклах.

Шаг 4. Пересчет кластерных центров.

Пересчет кластерных центров выполняется в соответствии со следующим уравнением:
:<math>
c_i = \frac{1}{|C_i|} \sum\limits_{k:\, u_k \in C_i} u_k,
</math>
где <math>|C_i|</math> -- количество элементов в <math>i</math>-ом кластере.

Шаг 5. Переход на шаг 2.

Описание взято из <ref>Нейский И.М. Классификация и сравнение методов кластеризации // Интеллектуальные технологии и системы. Сборник учебно-методических работ и статей аспирантов и студентов. – М.: НОК «CLAIM», 2006. – Выпуск 8. – С. 130-142.</ref>.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма Hard C-Means можно составить из множественных (всего их <math>nC</math>) вычислений квадратов нормы разности векторов <math>u_k</math> и кластерных центров <math>c_i</math>: <math>\|u_k-c_i\|^2</math>.

=== Макроструктура алгоритма ===
Как записано и в описании ядра алгоритма, основную часть метода составляют множественные (<math>Cn</math>) вычисления квадратов норм:

:<math>\|u_k-c_i\|^2</math>.

Также присутствуют данные вычислительные операции:

* Суммирование квадратов норм векторов:

:<math>
J = \sum\limits_{i=1}^C J_i = \sum\limits_{i=1}^C \left( \sum\limits_{k:\, u_k \in C_i} \|u_k -c_i \|^2 \right)
</math>

* Поэлементное суммирование векторов:

:<math>
c_i = \frac{1}{|C_i|} \sum\limits_{k:\, u_k \in C_i} u_k
</math>

=== Схема реализации последовательного алгоритма ===
Итерационный блок алгоритма можно описать на языке Python следующим образом:

<source lang="python3">
for i in range(n):
idx_min = 0
dist_min = ((u[i] - c[0]) ** 2).sum()

for j in range(1, C):
dist = ((u[i] - c[j]) ** 2).sum()
if dist < dist_min:
idx_min = j
dist_min = dist

M[i, idx_min] = 1
c_next[idx_min] += u[i]
c_next_cnt[idx_min] += 1
J += dist_min
</source>

=== Последовательная сложность алгоритма ===
Предполагаем, что предельная точность алгоритма достигаема менее, чем за <math>n</math> итераций. Иначе использование алгоритма можно считать нерациональным. Также предположим, что размерность <math>m</math> и количество кластерных центров <math>C</math> существенно меньше <math>n</math>.

Операция вычисления квадрата нормы разности векторов требует выполнения <math>m-1</math> арифметических операций сложения, <math>m</math> операций вычитания и <math>m</math> операций умножения.

Каждая итерация алгоритма требует выполнения:
* <math>nC</math> операций вычисления квадрата нормы разности векторов;
* <math>nC</math> операций сравнения квадрата нормы;
* <math>3n</math> операций сложения;

Таким образом, на каждой итерации имеем:
* <math>mnC</math> операций умножения;
* <math>(2mC + 3)n</math> арифметических операций сложения и вычитания;

В итоге имеем сложность последовательной реализации алгоритма <math>O(n)</math>.

=== Информационный граф ===
Граф алгоритма состоит из 4 видов вершин:

'''Первая''' группа вершин отмечена символом '''''M'''''. Ей соответствует вычисление минимального расстояния до кластерных центров, а также запись единицы в соответствующий столбец матрицы, обозначающей принадлежность кластерному центру:
* независимое вычисление расстояний от заданного элемента <math>u_i</math> до каждого из кластерных центров;
* последовательное сравнение полученных значений с целью отыскания максимума;
* операция записи 1 в соответствующий столбец матрицы принадлежности кластерным центрам;

'''Вторая''' вершина отмечена символом '''''J''''', на этом этапе происходит итоговый расчёт объектной функции.

'''Третья''' вершина помечена '''''if''''', на этом этапе происходит проверка условия достижения требуемой точности.

'''Четвертая''' соответствует операции пересчёта кластерных центров, она отмечена как '''''C'''''.

[[File:Cmeans.png|thumb|800px|center|Рисунок 1. Информационный граф алгоритма. Здесь '''''in''''' — ввод входных данных, '''''D''''' — вычисление минимального расстояния до кластерных центров и проставление принадлежности соответствующему кластерному центру, '''''J''''' — вычисление объектной функции по результатам полученных вычислений, '''''if''''' — проверка условия достижения желаемой точности, '''''C''''' — пересчёт кластерных центров и '''''out''''' — вывод полученных данных.]]

=== Ресурс параллелизма алгоритма ===
Основной ресурс параллелизма алгоритма составляет итерационный блок. Эта последовательность итераций может быть выполнена для каждого входного вектора <math>u_i</math> независимо. Однако, в конце выполнения каждого итерационного блока имеют место последовательные вычисления - сложение значений объектной функции, полученных независимо на каждом процессоре, а также перерасчет кластерных центров.

Высота [[глоссарий#Ярусно-параллельная форма графа алгоритма|ЯПФ]] оценивается как <math>O(1)</math> (при условии, что число итераций существенно меньше объёма выборки <math>n</math>). Ширина [[глоссарий#Ярусно-параллельная форма графа алгоритма|ЯПФ]] равна <math>n</math>.

Необходимо учитывать, что при небольшом объеме входной выборки, параллельная реализация алгоритма может лишь понизить производительность. В первую очередь это связано с пересылкой данных для вычисления итоговых значений объектной функции и кластерных центров.

=== Входные и выходные данные алгоритма ===
'''Входные данные:''' матрица <math>U\in \mathbb{R}^{n\times m}</math>, представляющая собой набор векторов <math>\{u_i\}_{i=1}^{n}, u_i \in \mathbb{R}^m</math>; количество кластеров <math>C \in \mathbb{N}</math>.

'''Объём входных данных:''' <math>nm+1</math>.

'''Выходные данные:''' набор векторов - кластерных центров <math>\{c_i\}_{i=1}^{C}, c_i \in \mathbb{R}^m</math>; матрица <math>M\in \mathbb{N}^{n\times C}</math> c информацией о разбиении объектов на кластера. Элемент <math>m_{ij}=1</math>, если <math>u_j \in C_i</math>, где <math>C_i</math> содержит все объекты <math>u</math>, принадлежащие кластеру <math>i</math>. Остальные элементы <math>m_{ij}=0</math>.

'''Объём выходных данных:''' <math>(n+m)C</math>.

=== Свойства алгоритма ===
Достоинства:

* лёгкость реализации;
* вычислительная простота;
* может служить для кластеризации больших наборов числовых данных;

Недостатки:

* задание количества кластеров;
* отсутствие гарантии в нахождении оптимального решения;

Соотношение последовательной и параллельной сложности алгоритма: линейное.

Вычислительная мощность алгоритма, как отношение числа операций к суммарному объему входных и выходных данных равна константе.

Алгоритм является недетерминированным, т.к. он является итерационным с выходом по точности, а также использует датчик случайных чисел для инициализации кластерных центров.

== Программная реализация алгоритма ==

=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
==== Локальность реализации алгоритма ====
===== Структура обращений в память и качественная оценка локальности =====
===== Количественная оценка локальности =====
=== Возможные способы и особенности параллельной реализации алгоритма ===

=== Масштабируемость алгоритма и его реализации ===

==== Масштабируемость алгоритма ====
==== Масштабируемость реализации алгоритма ====

=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===

=== Существующие реализации алгоритма ===
* [http://projects.jasmeet.me/2013/03/HardCMeans.html Последовательная реализация алгоритма на MatLab]
* [https://github.com/artpar/Hard-Clustering-implementation Последовательная реализация алгоритма на С++]

== Литература ==
<references />

Участник:Каледа Александр/Строгий алгоритм С средних (Hard C-Means)

2016-11-01T10:56:03Z

Каледа Александр: /* Общее описание алгоритма */

{{algorithm
| name = Строгий алгоритм С средних (Hard C-Means)
| serial_complexity = <math>O(n)</math>
| pf_height = <math>O(1)</math>
| pf_width = <math>O(n)</math>
| input_data = <math>nm+1</math>
| output_data = <math>(n+m)C</math>
}}

Авторы описания: [[Участник:Каледа_Александр|Каледа Александр]], [[Участник:Шапулин_Андрей|Шапулин Андрей]].

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===
'''Строгий алгоритм C средних''' ('''''Hard C-Means, HCM'''''; ''Jang, Sun and Mizutani, 1997'') один из наиболее широко используемых алгоритмов кластеризации данных<ref>\href{http://faculty.petra.ac.id/resmana/private/fuzzy/nfmod.pdf}{Jantzen J. Neurofuzzy Modelling. 1998. Электронное издание. 28 Стр.}</ref>. Алгоритм разбивает большие наборы векторов в многомерном пространстве по заранее заданному количеству кластеров (т.е. является управляемым).

На вход алгоритму подается набор векторов и количество кластеров. Дополнительно может задаваться пороговая величина объектной функции, при достижении которой алгоритм останавливается. После окончания работы алгоритма каждый вектор будет отнесет к определенному кластерному центру. Алгоритм, являясь итерационным, зависит от начальных значений кластерных центров, а следовательно может не сходиться к локальному минимуму.

На первом шаге алгоритма происходит инициализация кластерным центров, это можно сделать выбрав случайным образом вектора из входного набора. На следующем шаге начинается итерационный процесс, завершающийся при достижении порогового значения объектной функцией или при минимальном отличии, от значения на предыдущей итерации.

Вычисления, выполняющиеся на очередной итерации алгоритма:

# Расчёт рядовой матрицы (сопоставление вектора соответствующему кластерному центру).
# Расчёт объектной функции.
# Пересчёт кластерных центров.

=== Математическое описание алгоритма ===
Исходные данные: матрица <math>U\in \mathbb{R}^{n\times m}</math>, представляющая собой набор векторов <math>\{u_i\}_{i=1}^{n}, u_i \in \mathbb{R}^m</math>; количество кластеров <math>C \in \mathbb{N}</math>.

Вычисляемые данные: набор векторов - кластерных центров <math>\{c_i\}_{i=1}^{C}, c_i \in \mathbb{R}^m</math>; матрица <math>M\in \mathbb{N}^{n\times C}</math> c информацией о разбиении объектов на кластера. Элемент <math>m_{ij}=1</math>, если <math>u_j \in C_i</math>, где <math>C_i</math> содержит все объекты <math>u</math>, принадлежащие кластеру <math>i</math>. Остальные элементы <math>m_{ij}=0</math>.

Алгоритм:

Шаг 1. Инициализация кластерных центров <math>c_i, i = 1, 2, \dots, C.</math> Это можно сделать выбрав случайным образом C векторов из входного набора <math>\{u_i\}_{i=1}^{n}</math>

Шаг 2. Вычисление рядовой матрицы M.

Матрица <math>M</math> состоит из элементов <math>M = \|m_{ik}\|</math>.

:<math>
m_{ik} = \begin{cases}
1, & \|u_k-c_i\|^2 \leqslant \|u_k-c_j\|^2 \;\; \text{for all } i \neq j; \;\; (i,j=1,2,\ldots,C; \; k = 1,2,\ldots,n)\\
0, & \text{otherwise}.
\end{cases}
</math>

Шаг 3. Расчет объектной функции:

:<math>
J = \sum\limits_{i=1}^C J_i = \sum\limits_{i=1}^C \left( \sum\limits_{k:\, u_k \in C_i} \|u_k -c_i \|^2 \right)</math>.

На этом шаге происходит остановка и выход из цикла, если полученное значение ниже пороговой величины или полученное значение не сильно отличается от значений, полученных на предыдущих циклах.

Шаг 4. Пересчет кластерных центров.

Пересчет кластерных центров выполняется в соответствии со следующим уравнением:
:<math>
c_i = \frac{1}{|C_i|} \sum\limits_{k:\, u_k \in C_i} u_k,
</math>
где <math>|C_i|</math> -- количество элементов в <math>i</math>-ом кластере.

Шаг 5. Переход на шаг 2.

Описание взято из <ref>Нейский И.М. Классификация и сравнение методов кластеризации // Интеллектуальные технологии и системы. Сборник учебно-методических работ и статей аспирантов и студентов. – М.: НОК «CLAIM», 2006. – Выпуск 8. – С. 130-142.</ref>.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма Hard C-Means можно составить из множественных (всего их <math>nC</math>) вычислений квадратов нормы разности векторов <math>u_k</math> и кластерных центров <math>c_i</math>: <math>\|u_k-c_i\|^2</math>.

=== Макроструктура алгоритма ===
Как записано и в описании ядра алгоритма, основную часть метода составляют множественные (<math>Cn</math>) вычисления квадратов норм:

:<math>\|u_k-c_i\|^2</math>.

Также присутствуют данные вычислительные операции:

* Суммирование квадратов норм векторов:

:<math>
J = \sum\limits_{i=1}^C J_i = \sum\limits_{i=1}^C \left( \sum\limits_{k:\, u_k \in C_i} \|u_k -c_i \|^2 \right)
</math>

* Поэлементное суммирование векторов:

:<math>
c_i = \frac{1}{|C_i|} \sum\limits_{k:\, u_k \in C_i} u_k
</math>

=== Схема реализации последовательного алгоритма ===
Итерационный блок алгоритма можно описать на языке Python следующим образом:

<source lang="python3">
for i in range(n):
idx_min = 0
dist_min = ((u[i] - c[0]) ** 2).sum()

for j in range(1, C):
dist = ((u[i] - c[j]) ** 2).sum()
if dist < dist_min:
idx_min = j
dist_min = dist

M[i, idx_min] = 1
c_next[idx_min] += u[i]
c_next_cnt[idx_min] += 1
J += dist_min
</source>

=== Последовательная сложность алгоритма ===
Предполагаем, что предельная точность алгоритма достигаема менее, чем за <math>n</math> итераций. Иначе использование алгоритма можно считать нерациональным. Также предположим, что размерность <math>m</math> и количество кластерных центров <math>C</math> существенно меньше <math>n</math>.

Операция вычисления квадрата нормы разности векторов требует выполнения <math>m-1</math> арифметических операций сложения, <math>m</math> операций вычитания и <math>m</math> операций умножения.

Каждая итерация алгоритма требует выполнения:
* <math>nC</math> операций вычисления квадрата нормы разности векторов;
* <math>nC</math> операций сравнения квадрата нормы;
* <math>3n</math> операций сложения;

Таким образом, на каждой итерации имеем:
* <math>mnC</math> операций умножения;
* <math>(2mC + 3)n</math> арифметических операций сложения и вычитания;

В итоге имеем сложность последовательной реализации алгоритма <math>O(n)</math>.

=== Информационный граф ===
Граф алгоритма состоит из 4 видов вершин:

'''Первая''' группа вершин отмечена символом '''''M'''''. Ей соответствует вычисление минимального расстояния до кластерных центров, а также запись единицы в соответствующий столбец матрицы, обозначающей принадлежность кластерному центру:
* независимое вычисление расстояний от заданного элемента <math>u_i</math> до каждого из кластерных центров;
* последовательное сравнение полученных значений с целью отыскания максимума;
* операция записи 1 в соответствующий столбец матрицы принадлежности кластерным центрам;

'''Вторая''' вершина отмечена символом '''''J''''', на этом этапе происходит итоговый расчёт объектной функции.

'''Третья''' вершина помечена '''''if''''', на этом этапе происходит проверка условия достижения требуемой точности.

'''Четвертая''' соответствует операции пересчёта кластерных центров, она отмечена как '''''C'''''.

[[File:Cmeans.png|thumb|800px|center|Рисунок 1. Информационный граф алгоритма. Здесь '''''in''''' — ввод входных данных, '''''D''''' — вычисление минимального расстояния до кластерных центров и проставление принадлежности соответствующему кластерному центру, '''''J''''' — вычисление объектной функции по результатам полученных вычислений, '''''if''''' — проверка условия достижения желаемой точности, '''''C''''' — пересчёт кластерных центров и '''''out''''' — вывод полученных данных.]]

=== Ресурс параллелизма алгоритма ===
Основной ресурс параллелизма алгоритма составляет итерационный блок. Эта последовательность итераций может быть выполнена для каждого входного вектора <math>u_i</math> независимо. Однако, в конце выполнения каждого итерационного блока имеют место последовательные вычисления - сложение значений объектной функции, полученных независимо на каждом процессоре, а также перерасчет кластерных центров.

Высота [[глоссарий#Ярусно-параллельная форма графа алгоритма|ЯПФ]] оценивается как <math>O(1)</math> (при условии, что число итераций существенно меньше объёма выборки <math>n</math>). Ширина [[глоссарий#Ярусно-параллельная форма графа алгоритма|ЯПФ]] равна <math>n</math>.

Необходимо учитывать, что при небольшом объеме входной выборки, параллельная реализация алгоритма может лишь понизить производительность. В первую очередь это связано с пересылкой данных для вычисления итоговых значений объектной функции и кластерных центров.

=== Входные и выходные данные алгоритма ===
'''Входные данные:''' матрица <math>U\in \mathbb{R}^{n\times m}</math>, представляющая собой набор векторов <math>\{u_i\}_{i=1}^{n}, u_i \in \mathbb{R}^m</math>; количество кластеров <math>C \in \mathbb{N}</math>.

'''Объём входных данных:''' <math>nm+1</math>.

'''Выходные данные:''' набор векторов - кластерных центров <math>\{c_i\}_{i=1}^{C}, c_i \in \mathbb{R}^m</math>; матрица <math>M\in \mathbb{N}^{n\times C}</math> c информацией о разбиении объектов на кластера. Элемент <math>m_{ij}=1</math>, если <math>u_j \in C_i</math>, где <math>C_i</math> содержит все объекты <math>u</math>, принадлежащие кластеру <math>i</math>. Остальные элементы <math>m_{ij}=0</math>.

'''Объём выходных данных:''' <math>(n+m)C</math>.

=== Свойства алгоритма ===
Достоинства:

* лёгкость реализации;
* вычислительная простота;
* может служить для кластеризации больших наборов числовых данных;

Недостатки:

* задание количества кластеров;
* отсутствие гарантии в нахождении оптимального решения;

Соотношение последовательной и параллельной сложности алгоритма: линейное.

Вычислительная мощность алгоритма, как отношение числа операций к суммарному объему входных и выходных данных равна константе.

Алгоритм является недетерминированным, т.к. он является итерационным с выходом по точности, а также использует датчик случайных чисел для инициализации кластерных центров.

== Программная реализация алгоритма ==

=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
==== Локальность реализации алгоритма ====
===== Структура обращений в память и качественная оценка локальности =====
===== Количественная оценка локальности =====
=== Возможные способы и особенности параллельной реализации алгоритма ===

=== Масштабируемость алгоритма и его реализации ===

==== Масштабируемость алгоритма ====
==== Масштабируемость реализации алгоритма ====

=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===

=== Существующие реализации алгоритма ===
* [http://projects.jasmeet.me/2013/03/HardCMeans.html Последовательная реализация алгоритма на MatLab]
* [https://github.com/artpar/Hard-Clustering-implementation Последовательная реализация алгоритма на С++]

== Литература ==
<references />

Участник:Каледа Александр/Строгий алгоритм С средних (Hard C-Means)

2016-11-01T10:55:37Z

Каледа Александр: /* Общее описание алгоритма */

{{algorithm
| name = Строгий алгоритм С средних (Hard C-Means)
| serial_complexity = <math>O(n)</math>
| pf_height = <math>O(1)</math>
| pf_width = <math>O(n)</math>
| input_data = <math>nm+1</math>
| output_data = <math>(n+m)C</math>
}}

Авторы описания: [[Участник:Каледа_Александр|Каледа Александр]], [[Участник:Шапулин_Андрей|Шапулин Андрей]].

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===
'''Строгий алгоритм C средних''' ('''''Hard C-Means, HCM'''''; ''Jang, Sun and Mizutani, 1997'') один из наиболее широко используемых алгоритмов кластеризации данных<ref>\href{http://faculty.petra.ac.id/resmana/private/fuzzy/nfmod.pdf}{Jantzen J. Neurofuzzy Modelling. 1998. Электронное издание. 28 Стр.}{}</ref>. Алгоритм разбивает большие наборы векторов в многомерном пространстве по заранее заданному количеству кластеров (т.е. является управляемым).

На вход алгоритму подается набор векторов и количество кластеров. Дополнительно может задаваться пороговая величина объектной функции, при достижении которой алгоритм останавливается. После окончания работы алгоритма каждый вектор будет отнесет к определенному кластерному центру. Алгоритм, являясь итерационным, зависит от начальных значений кластерных центров, а следовательно может не сходиться к локальному минимуму.

На первом шаге алгоритма происходит инициализация кластерным центров, это можно сделать выбрав случайным образом вектора из входного набора. На следующем шаге начинается итерационный процесс, завершающийся при достижении порогового значения объектной функцией или при минимальном отличии, от значения на предыдущей итерации.

Вычисления, выполняющиеся на очередной итерации алгоритма:

# Расчёт рядовой матрицы (сопоставление вектора соответствующему кластерному центру).
# Расчёт объектной функции.
# Пересчёт кластерных центров.

=== Математическое описание алгоритма ===
Исходные данные: матрица <math>U\in \mathbb{R}^{n\times m}</math>, представляющая собой набор векторов <math>\{u_i\}_{i=1}^{n}, u_i \in \mathbb{R}^m</math>; количество кластеров <math>C \in \mathbb{N}</math>.

Вычисляемые данные: набор векторов - кластерных центров <math>\{c_i\}_{i=1}^{C}, c_i \in \mathbb{R}^m</math>; матрица <math>M\in \mathbb{N}^{n\times C}</math> c информацией о разбиении объектов на кластера. Элемент <math>m_{ij}=1</math>, если <math>u_j \in C_i</math>, где <math>C_i</math> содержит все объекты <math>u</math>, принадлежащие кластеру <math>i</math>. Остальные элементы <math>m_{ij}=0</math>.

Алгоритм:

Шаг 1. Инициализация кластерных центров <math>c_i, i = 1, 2, \dots, C.</math> Это можно сделать выбрав случайным образом C векторов из входного набора <math>\{u_i\}_{i=1}^{n}</math>

Шаг 2. Вычисление рядовой матрицы M.

Матрица <math>M</math> состоит из элементов <math>M = \|m_{ik}\|</math>.

:<math>
m_{ik} = \begin{cases}
1, & \|u_k-c_i\|^2 \leqslant \|u_k-c_j\|^2 \;\; \text{for all } i \neq j; \;\; (i,j=1,2,\ldots,C; \; k = 1,2,\ldots,n)\\
0, & \text{otherwise}.
\end{cases}
</math>

Шаг 3. Расчет объектной функции:

:<math>
J = \sum\limits_{i=1}^C J_i = \sum\limits_{i=1}^C \left( \sum\limits_{k:\, u_k \in C_i} \|u_k -c_i \|^2 \right)</math>.

На этом шаге происходит остановка и выход из цикла, если полученное значение ниже пороговой величины или полученное значение не сильно отличается от значений, полученных на предыдущих циклах.

Шаг 4. Пересчет кластерных центров.

Пересчет кластерных центров выполняется в соответствии со следующим уравнением:
:<math>
c_i = \frac{1}{|C_i|} \sum\limits_{k:\, u_k \in C_i} u_k,
</math>
где <math>|C_i|</math> -- количество элементов в <math>i</math>-ом кластере.

Шаг 5. Переход на шаг 2.

Описание взято из <ref>Нейский И.М. Классификация и сравнение методов кластеризации // Интеллектуальные технологии и системы. Сборник учебно-методических работ и статей аспирантов и студентов. – М.: НОК «CLAIM», 2006. – Выпуск 8. – С. 130-142.</ref>.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма Hard C-Means можно составить из множественных (всего их <math>nC</math>) вычислений квадратов нормы разности векторов <math>u_k</math> и кластерных центров <math>c_i</math>: <math>\|u_k-c_i\|^2</math>.

=== Макроструктура алгоритма ===
Как записано и в описании ядра алгоритма, основную часть метода составляют множественные (<math>Cn</math>) вычисления квадратов норм:

:<math>\|u_k-c_i\|^2</math>.

Также присутствуют данные вычислительные операции:

* Суммирование квадратов норм векторов:

:<math>
J = \sum\limits_{i=1}^C J_i = \sum\limits_{i=1}^C \left( \sum\limits_{k:\, u_k \in C_i} \|u_k -c_i \|^2 \right)
</math>

* Поэлементное суммирование векторов:

:<math>
c_i = \frac{1}{|C_i|} \sum\limits_{k:\, u_k \in C_i} u_k
</math>

=== Схема реализации последовательного алгоритма ===
Итерационный блок алгоритма можно описать на языке Python следующим образом:

<source lang="python3">
for i in range(n):
idx_min = 0
dist_min = ((u[i] - c[0]) ** 2).sum()

for j in range(1, C):
dist = ((u[i] - c[j]) ** 2).sum()
if dist < dist_min:
idx_min = j
dist_min = dist

M[i, idx_min] = 1
c_next[idx_min] += u[i]
c_next_cnt[idx_min] += 1
J += dist_min
</source>

=== Последовательная сложность алгоритма ===
Предполагаем, что предельная точность алгоритма достигаема менее, чем за <math>n</math> итераций. Иначе использование алгоритма можно считать нерациональным. Также предположим, что размерность <math>m</math> и количество кластерных центров <math>C</math> существенно меньше <math>n</math>.

Операция вычисления квадрата нормы разности векторов требует выполнения <math>m-1</math> арифметических операций сложения, <math>m</math> операций вычитания и <math>m</math> операций умножения.

Каждая итерация алгоритма требует выполнения:
* <math>nC</math> операций вычисления квадрата нормы разности векторов;
* <math>nC</math> операций сравнения квадрата нормы;
* <math>3n</math> операций сложения;

Таким образом, на каждой итерации имеем:
* <math>mnC</math> операций умножения;
* <math>(2mC + 3)n</math> арифметических операций сложения и вычитания;

В итоге имеем сложность последовательной реализации алгоритма <math>O(n)</math>.

=== Информационный граф ===
Граф алгоритма состоит из 4 видов вершин:

'''Первая''' группа вершин отмечена символом '''''M'''''. Ей соответствует вычисление минимального расстояния до кластерных центров, а также запись единицы в соответствующий столбец матрицы, обозначающей принадлежность кластерному центру:
* независимое вычисление расстояний от заданного элемента <math>u_i</math> до каждого из кластерных центров;
* последовательное сравнение полученных значений с целью отыскания максимума;
* операция записи 1 в соответствующий столбец матрицы принадлежности кластерным центрам;

'''Вторая''' вершина отмечена символом '''''J''''', на этом этапе происходит итоговый расчёт объектной функции.

'''Третья''' вершина помечена '''''if''''', на этом этапе происходит проверка условия достижения требуемой точности.

'''Четвертая''' соответствует операции пересчёта кластерных центров, она отмечена как '''''C'''''.

[[File:Cmeans.png|thumb|800px|center|Рисунок 1. Информационный граф алгоритма. Здесь '''''in''''' — ввод входных данных, '''''D''''' — вычисление минимального расстояния до кластерных центров и проставление принадлежности соответствующему кластерному центру, '''''J''''' — вычисление объектной функции по результатам полученных вычислений, '''''if''''' — проверка условия достижения желаемой точности, '''''C''''' — пересчёт кластерных центров и '''''out''''' — вывод полученных данных.]]

=== Ресурс параллелизма алгоритма ===
Основной ресурс параллелизма алгоритма составляет итерационный блок. Эта последовательность итераций может быть выполнена для каждого входного вектора <math>u_i</math> независимо. Однако, в конце выполнения каждого итерационного блока имеют место последовательные вычисления - сложение значений объектной функции, полученных независимо на каждом процессоре, а также перерасчет кластерных центров.

Высота [[глоссарий#Ярусно-параллельная форма графа алгоритма|ЯПФ]] оценивается как <math>O(1)</math> (при условии, что число итераций существенно меньше объёма выборки <math>n</math>). Ширина [[глоссарий#Ярусно-параллельная форма графа алгоритма|ЯПФ]] равна <math>n</math>.

Необходимо учитывать, что при небольшом объеме входной выборки, параллельная реализация алгоритма может лишь понизить производительность. В первую очередь это связано с пересылкой данных для вычисления итоговых значений объектной функции и кластерных центров.

=== Входные и выходные данные алгоритма ===
'''Входные данные:''' матрица <math>U\in \mathbb{R}^{n\times m}</math>, представляющая собой набор векторов <math>\{u_i\}_{i=1}^{n}, u_i \in \mathbb{R}^m</math>; количество кластеров <math>C \in \mathbb{N}</math>.

'''Объём входных данных:''' <math>nm+1</math>.

'''Выходные данные:''' набор векторов - кластерных центров <math>\{c_i\}_{i=1}^{C}, c_i \in \mathbb{R}^m</math>; матрица <math>M\in \mathbb{N}^{n\times C}</math> c информацией о разбиении объектов на кластера. Элемент <math>m_{ij}=1</math>, если <math>u_j \in C_i</math>, где <math>C_i</math> содержит все объекты <math>u</math>, принадлежащие кластеру <math>i</math>. Остальные элементы <math>m_{ij}=0</math>.

'''Объём выходных данных:''' <math>(n+m)C</math>.

=== Свойства алгоритма ===
Достоинства:

* лёгкость реализации;
* вычислительная простота;
* может служить для кластеризации больших наборов числовых данных;

Недостатки:

* задание количества кластеров;
* отсутствие гарантии в нахождении оптимального решения;

Соотношение последовательной и параллельной сложности алгоритма: линейное.

Вычислительная мощность алгоритма, как отношение числа операций к суммарному объему входных и выходных данных равна константе.

Алгоритм является недетерминированным, т.к. он является итерационным с выходом по точности, а также использует датчик случайных чисел для инициализации кластерных центров.

== Программная реализация алгоритма ==

=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
==== Локальность реализации алгоритма ====
===== Структура обращений в память и качественная оценка локальности =====
===== Количественная оценка локальности =====
=== Возможные способы и особенности параллельной реализации алгоритма ===

=== Масштабируемость алгоритма и его реализации ===

==== Масштабируемость алгоритма ====
==== Масштабируемость реализации алгоритма ====

=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===

=== Существующие реализации алгоритма ===
* [http://projects.jasmeet.me/2013/03/HardCMeans.html Последовательная реализация алгоритма на MatLab]
* [https://github.com/artpar/Hard-Clustering-implementation Последовательная реализация алгоритма на С++]

== Литература ==
<references />

Участник:Каледа Александр/Строгий алгоритм С средних (Hard C-Means)

2016-11-01T10:51:10Z

Каледа Александр: /* Программная реализация алгоритма */

{{algorithm
| name = Строгий алгоритм С средних (Hard C-Means)
| serial_complexity = <math>O(n)</math>
| pf_height = <math>O(1)</math>
| pf_width = <math>O(n)</math>
| input_data = <math>nm+1</math>
| output_data = <math>(n+m)C</math>
}}

Авторы описания: [[Участник:Каледа_Александр|Каледа Александр]], [[Участник:Шапулин_Андрей|Шапулин Андрей]].

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===
'''Строгий алгоритм C средних''' ('''''Hard C-Means, HCM'''''; ''Jang, Sun and Mizutani, 1997'') один из наиболее широко используемых алгоритмов кластеризации данных<ref>Jantzen J. Neurofuzzy Modelling. 1998. Электронное издание. 28 Стр.</ref>. Алгоритм разбивает большие наборы векторов в многомерном пространстве по заранее заданному количеству кластеров (т.е. является управляемым).

На вход алгоритму подается набор векторов и количество кластеров. Дополнительно может задаваться пороговая величина объектной функции, при достижении которой алгоритм останавливается. После окончания работы алгоритма каждый вектор будет отнесет к определенному кластерному центру. Алгоритм, являясь итерационным, зависит от начальных значений кластерных центров, а следовательно может не сходиться к локальному минимуму.

На первом шаге алгоритма происходит инициализация кластерным центров, это можно сделать выбрав случайным образом вектора из входного набора. На следующем шаге начинается итерационный процесс, завершающийся при достижении порогового значения объектной функцией или при минимальном отличии, от значения на предыдущей итерации.

Вычисления, выполняющиеся на очередной итерации алгоритма:

# Расчёт рядовой матрицы (сопоставление вектора соответствующему кластерному центру).
# Расчёт объектной функции.
# Пересчёт кластерных центров.

=== Математическое описание алгоритма ===
Исходные данные: матрица <math>U\in \mathbb{R}^{n\times m}</math>, представляющая собой набор векторов <math>\{u_i\}_{i=1}^{n}, u_i \in \mathbb{R}^m</math>; количество кластеров <math>C \in \mathbb{N}</math>.

Вычисляемые данные: набор векторов - кластерных центров <math>\{c_i\}_{i=1}^{C}, c_i \in \mathbb{R}^m</math>; матрица <math>M\in \mathbb{N}^{n\times C}</math> c информацией о разбиении объектов на кластера. Элемент <math>m_{ij}=1</math>, если <math>u_j \in C_i</math>, где <math>C_i</math> содержит все объекты <math>u</math>, принадлежащие кластеру <math>i</math>. Остальные элементы <math>m_{ij}=0</math>.

Алгоритм:

Шаг 1. Инициализация кластерных центров <math>c_i, i = 1, 2, \dots, C.</math> Это можно сделать выбрав случайным образом C векторов из входного набора <math>\{u_i\}_{i=1}^{n}</math>

Шаг 2. Вычисление рядовой матрицы M.

Матрица <math>M</math> состоит из элементов <math>M = \|m_{ik}\|</math>.

:<math>
m_{ik} = \begin{cases}
1, & \|u_k-c_i\|^2 \leqslant \|u_k-c_j\|^2 \;\; \text{for all } i \neq j; \;\; (i,j=1,2,\ldots,C; \; k = 1,2,\ldots,n)\\
0, & \text{otherwise}.
\end{cases}
</math>

Шаг 3. Расчет объектной функции:

:<math>
J = \sum\limits_{i=1}^C J_i = \sum\limits_{i=1}^C \left( \sum\limits_{k:\, u_k \in C_i} \|u_k -c_i \|^2 \right)</math>.

На этом шаге происходит остановка и выход из цикла, если полученное значение ниже пороговой величины или полученное значение не сильно отличается от значений, полученных на предыдущих циклах.

Шаг 4. Пересчет кластерных центров.

Пересчет кластерных центров выполняется в соответствии со следующим уравнением:
:<math>
c_i = \frac{1}{|C_i|} \sum\limits_{k:\, u_k \in C_i} u_k,
</math>
где <math>|C_i|</math> -- количество элементов в <math>i</math>-ом кластере.

Шаг 5. Переход на шаг 2.

Описание взято из <ref>Нейский И.М. Классификация и сравнение методов кластеризации // Интеллектуальные технологии и системы. Сборник учебно-методических работ и статей аспирантов и студентов. – М.: НОК «CLAIM», 2006. – Выпуск 8. – С. 130-142.</ref>.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма Hard C-Means можно составить из множественных (всего их <math>nC</math>) вычислений квадратов нормы разности векторов <math>u_k</math> и кластерных центров <math>c_i</math>: <math>\|u_k-c_i\|^2</math>.

=== Макроструктура алгоритма ===
Как записано и в описании ядра алгоритма, основную часть метода составляют множественные (<math>Cn</math>) вычисления квадратов норм:

:<math>\|u_k-c_i\|^2</math>.

Также присутствуют данные вычислительные операции:

* Суммирование квадратов норм векторов:

:<math>
J = \sum\limits_{i=1}^C J_i = \sum\limits_{i=1}^C \left( \sum\limits_{k:\, u_k \in C_i} \|u_k -c_i \|^2 \right)
</math>

* Поэлементное суммирование векторов:

:<math>
c_i = \frac{1}{|C_i|} \sum\limits_{k:\, u_k \in C_i} u_k
</math>

=== Схема реализации последовательного алгоритма ===
Итерационный блок алгоритма можно описать на языке Python следующим образом:

<source lang="python3">
for i in range(n):
idx_min = 0
dist_min = ((u[i] - c[0]) ** 2).sum()

for j in range(1, C):
dist = ((u[i] - c[j]) ** 2).sum()
if dist < dist_min:
idx_min = j
dist_min = dist

M[i, idx_min] = 1
c_next[idx_min] += u[i]
c_next_cnt[idx_min] += 1
J += dist_min
</source>

=== Последовательная сложность алгоритма ===
Предполагаем, что предельная точность алгоритма достигаема менее, чем за <math>n</math> итераций. Иначе использование алгоритма можно считать нерациональным. Также предположим, что размерность <math>m</math> и количество кластерных центров <math>C</math> существенно меньше <math>n</math>.

Операция вычисления квадрата нормы разности векторов требует выполнения <math>m-1</math> арифметических операций сложения, <math>m</math> операций вычитания и <math>m</math> операций умножения.

Каждая итерация алгоритма требует выполнения:
* <math>nC</math> операций вычисления квадрата нормы разности векторов;
* <math>nC</math> операций сравнения квадрата нормы;
* <math>3n</math> операций сложения;

Таким образом, на каждой итерации имеем:
* <math>mnC</math> операций умножения;
* <math>(2mC + 3)n</math> арифметических операций сложения и вычитания;

В итоге имеем сложность последовательной реализации алгоритма <math>O(n)</math>.

=== Информационный граф ===
Граф алгоритма состоит из 4 видов вершин:

'''Первая''' группа вершин отмечена символом '''''M'''''. Ей соответствует вычисление минимального расстояния до кластерных центров, а также запись единицы в соответствующий столбец матрицы, обозначающей принадлежность кластерному центру:
* независимое вычисление расстояний от заданного элемента <math>u_i</math> до каждого из кластерных центров;
* последовательное сравнение полученных значений с целью отыскания максимума;
* операция записи 1 в соответствующий столбец матрицы принадлежности кластерным центрам;

'''Вторая''' вершина отмечена символом '''''J''''', на этом этапе происходит итоговый расчёт объектной функции.

'''Третья''' вершина помечена '''''if''''', на этом этапе происходит проверка условия достижения требуемой точности.

'''Четвертая''' соответствует операции пересчёта кластерных центров, она отмечена как '''''C'''''.

[[File:Cmeans.png|thumb|800px|center|Рисунок 1. Информационный граф алгоритма. Здесь '''''in''''' — ввод входных данных, '''''D''''' — вычисление минимального расстояния до кластерных центров и проставление принадлежности соответствующему кластерному центру, '''''J''''' — вычисление объектной функции по результатам полученных вычислений, '''''if''''' — проверка условия достижения желаемой точности, '''''C''''' — пересчёт кластерных центров и '''''out''''' — вывод полученных данных.]]

=== Ресурс параллелизма алгоритма ===
Основной ресурс параллелизма алгоритма составляет итерационный блок. Эта последовательность итераций может быть выполнена для каждого входного вектора <math>u_i</math> независимо. Однако, в конце выполнения каждого итерационного блока имеют место последовательные вычисления - сложение значений объектной функции, полученных независимо на каждом процессоре, а также перерасчет кластерных центров.

Высота [[глоссарий#Ярусно-параллельная форма графа алгоритма|ЯПФ]] оценивается как <math>O(1)</math> (при условии, что число итераций существенно меньше объёма выборки <math>n</math>). Ширина [[глоссарий#Ярусно-параллельная форма графа алгоритма|ЯПФ]] равна <math>n</math>.

Необходимо учитывать, что при небольшом объеме входной выборки, параллельная реализация алгоритма может лишь понизить производительность. В первую очередь это связано с пересылкой данных для вычисления итоговых значений объектной функции и кластерных центров.

=== Входные и выходные данные алгоритма ===
'''Входные данные:''' матрица <math>U\in \mathbb{R}^{n\times m}</math>, представляющая собой набор векторов <math>\{u_i\}_{i=1}^{n}, u_i \in \mathbb{R}^m</math>; количество кластеров <math>C \in \mathbb{N}</math>.

'''Объём входных данных:''' <math>nm+1</math>.

'''Выходные данные:''' набор векторов - кластерных центров <math>\{c_i\}_{i=1}^{C}, c_i \in \mathbb{R}^m</math>; матрица <math>M\in \mathbb{N}^{n\times C}</math> c информацией о разбиении объектов на кластера. Элемент <math>m_{ij}=1</math>, если <math>u_j \in C_i</math>, где <math>C_i</math> содержит все объекты <math>u</math>, принадлежащие кластеру <math>i</math>. Остальные элементы <math>m_{ij}=0</math>.

'''Объём выходных данных:''' <math>(n+m)C</math>.

=== Свойства алгоритма ===
Достоинства:

* лёгкость реализации;
* вычислительная простота;
* может служить для кластеризации больших наборов числовых данных;

Недостатки:

* задание количества кластеров;
* отсутствие гарантии в нахождении оптимального решения;

Соотношение последовательной и параллельной сложности алгоритма: линейное.

Вычислительная мощность алгоритма, как отношение числа операций к суммарному объему входных и выходных данных равна константе.

Алгоритм является недетерминированным, т.к. он является итерационным с выходом по точности, а также использует датчик случайных чисел для инициализации кластерных центров.

== Программная реализация алгоритма ==

=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
==== Локальность реализации алгоритма ====
===== Структура обращений в память и качественная оценка локальности =====
===== Количественная оценка локальности =====
=== Возможные способы и особенности параллельной реализации алгоритма ===

=== Масштабируемость алгоритма и его реализации ===

==== Масштабируемость алгоритма ====
==== Масштабируемость реализации алгоритма ====

=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===

=== Существующие реализации алгоритма ===
* [http://projects.jasmeet.me/2013/03/HardCMeans.html Последовательная реализация алгоритма на MatLab]
* [https://github.com/artpar/Hard-Clustering-implementation Последовательная реализация алгоритма на С++]

== Литература ==
<references />

Участник:Каледа Александр/Строгий алгоритм С средних (Hard C-Means)

2016-11-01T10:39:22Z

Каледа Александр:

{{algorithm
| name = Строгий алгоритм С средних (Hard C-Means)
| serial_complexity = <math>O(n)</math>
| pf_height = <math>O(1)</math>
| pf_width = <math>O(n)</math>
| input_data = <math>nm+1</math>
| output_data = <math>(n+m)C</math>
}}

Авторы описания: [[Участник:Каледа_Александр|Каледа Александр]], [[Участник:Шапулин_Андрей|Шапулин Андрей]].

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===
'''Строгий алгоритм C средних''' ('''''Hard C-Means, HCM'''''; ''Jang, Sun and Mizutani, 1997'') один из наиболее широко используемых алгоритмов кластеризации данных<ref>Jantzen J. Neurofuzzy Modelling. 1998. Электронное издание. 28 Стр.</ref>. Алгоритм разбивает большие наборы векторов в многомерном пространстве по заранее заданному количеству кластеров (т.е. является управляемым).

На вход алгоритму подается набор векторов и количество кластеров. Дополнительно может задаваться пороговая величина объектной функции, при достижении которой алгоритм останавливается. После окончания работы алгоритма каждый вектор будет отнесет к определенному кластерному центру. Алгоритм, являясь итерационным, зависит от начальных значений кластерных центров, а следовательно может не сходиться к локальному минимуму.

На первом шаге алгоритма происходит инициализация кластерным центров, это можно сделать выбрав случайным образом вектора из входного набора. На следующем шаге начинается итерационный процесс, завершающийся при достижении порогового значения объектной функцией или при минимальном отличии, от значения на предыдущей итерации.

Вычисления, выполняющиеся на очередной итерации алгоритма:

# Расчёт рядовой матрицы (сопоставление вектора соответствующему кластерному центру).
# Расчёт объектной функции.
# Пересчёт кластерных центров.

=== Математическое описание алгоритма ===
Исходные данные: матрица <math>U\in \mathbb{R}^{n\times m}</math>, представляющая собой набор векторов <math>\{u_i\}_{i=1}^{n}, u_i \in \mathbb{R}^m</math>; количество кластеров <math>C \in \mathbb{N}</math>.

Вычисляемые данные: набор векторов - кластерных центров <math>\{c_i\}_{i=1}^{C}, c_i \in \mathbb{R}^m</math>; матрица <math>M\in \mathbb{N}^{n\times C}</math> c информацией о разбиении объектов на кластера. Элемент <math>m_{ij}=1</math>, если <math>u_j \in C_i</math>, где <math>C_i</math> содержит все объекты <math>u</math>, принадлежащие кластеру <math>i</math>. Остальные элементы <math>m_{ij}=0</math>.

Алгоритм:

Шаг 1. Инициализация кластерных центров <math>c_i, i = 1, 2, \dots, C.</math> Это можно сделать выбрав случайным образом C векторов из входного набора <math>\{u_i\}_{i=1}^{n}</math>

Шаг 2. Вычисление рядовой матрицы M.

Матрица <math>M</math> состоит из элементов <math>M = \|m_{ik}\|</math>.

:<math>
m_{ik} = \begin{cases}
1, & \|u_k-c_i\|^2 \leqslant \|u_k-c_j\|^2 \;\; \text{for all } i \neq j; \;\; (i,j=1,2,\ldots,C; \; k = 1,2,\ldots,n)\\
0, & \text{otherwise}.
\end{cases}
</math>

Шаг 3. Расчет объектной функции:

:<math>
J = \sum\limits_{i=1}^C J_i = \sum\limits_{i=1}^C \left( \sum\limits_{k:\, u_k \in C_i} \|u_k -c_i \|^2 \right)</math>.

На этом шаге происходит остановка и выход из цикла, если полученное значение ниже пороговой величины или полученное значение не сильно отличается от значений, полученных на предыдущих циклах.

Шаг 4. Пересчет кластерных центров.

Пересчет кластерных центров выполняется в соответствии со следующим уравнением:
:<math>
c_i = \frac{1}{|C_i|} \sum\limits_{k:\, u_k \in C_i} u_k,
</math>
где <math>|C_i|</math> -- количество элементов в <math>i</math>-ом кластере.

Шаг 5. Переход на шаг 2.

Описание взято из <ref>Нейский И.М. Классификация и сравнение методов кластеризации // Интеллектуальные технологии и системы. Сборник учебно-методических работ и статей аспирантов и студентов. – М.: НОК «CLAIM», 2006. – Выпуск 8. – С. 130-142.</ref>.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма Hard C-Means можно составить из множественных (всего их <math>nC</math>) вычислений квадратов нормы разности векторов <math>u_k</math> и кластерных центров <math>c_i</math>: <math>\|u_k-c_i\|^2</math>.

=== Макроструктура алгоритма ===
Как записано и в описании ядра алгоритма, основную часть метода составляют множественные (<math>Cn</math>) вычисления квадратов норм:

:<math>\|u_k-c_i\|^2</math>.

Также присутствуют данные вычислительные операции:

* Суммирование квадратов норм векторов:

:<math>
J = \sum\limits_{i=1}^C J_i = \sum\limits_{i=1}^C \left( \sum\limits_{k:\, u_k \in C_i} \|u_k -c_i \|^2 \right)
</math>

* Поэлементное суммирование векторов:

:<math>
c_i = \frac{1}{|C_i|} \sum\limits_{k:\, u_k \in C_i} u_k
</math>

=== Схема реализации последовательного алгоритма ===
Итерационный блок алгоритма можно описать на языке Python следующим образом:

<source lang="python3">
for i in range(n):
idx_min = 0
dist_min = ((u[i] - c[0]) ** 2).sum()

for j in range(1, C):
dist = ((u[i] - c[j]) ** 2).sum()
if dist < dist_min:
idx_min = j
dist_min = dist

M[i, idx_min] = 1
c_next[idx_min] += u[i]
c_next_cnt[idx_min] += 1
J += dist_min
</source>

=== Последовательная сложность алгоритма ===
Предполагаем, что предельная точность алгоритма достигаема менее, чем за <math>n</math> итераций. Иначе использование алгоритма можно считать нерациональным. Также предположим, что размерность <math>m</math> и количество кластерных центров <math>C</math> существенно меньше <math>n</math>.

Операция вычисления квадрата нормы разности векторов требует выполнения <math>m-1</math> арифметических операций сложения, <math>m</math> операций вычитания и <math>m</math> операций умножения.

Каждая итерация алгоритма требует выполнения:
* <math>nC</math> операций вычисления квадрата нормы разности векторов;
* <math>nC</math> операций сравнения квадрата нормы;
* <math>3n</math> операций сложения;

Таким образом, на каждой итерации имеем:
* <math>mnC</math> операций умножения;
* <math>(2mC + 3)n</math> арифметических операций сложения и вычитания;

В итоге имеем сложность последовательной реализации алгоритма <math>O(n)</math>.

=== Информационный граф ===
Граф алгоритма состоит из 4 видов вершин:

'''Первая''' группа вершин отмечена символом '''''M'''''. Ей соответствует вычисление минимального расстояния до кластерных центров, а также запись единицы в соответствующий столбец матрицы, обозначающей принадлежность кластерному центру:
* независимое вычисление расстояний от заданного элемента <math>u_i</math> до каждого из кластерных центров;
* последовательное сравнение полученных значений с целью отыскания максимума;
* операция записи 1 в соответствующий столбец матрицы принадлежности кластерным центрам;

'''Вторая''' вершина отмечена символом '''''J''''', на этом этапе происходит итоговый расчёт объектной функции.

'''Третья''' вершина помечена '''''if''''', на этом этапе происходит проверка условия достижения требуемой точности.

'''Четвертая''' соответствует операции пересчёта кластерных центров, она отмечена как '''''C'''''.

[[File:Cmeans.png|thumb|800px|center|Рисунок 1. Информационный граф алгоритма. Здесь '''''in''''' — ввод входных данных, '''''D''''' — вычисление минимального расстояния до кластерных центров и проставление принадлежности соответствующему кластерному центру, '''''J''''' — вычисление объектной функции по результатам полученных вычислений, '''''if''''' — проверка условия достижения желаемой точности, '''''C''''' — пересчёт кластерных центров и '''''out''''' — вывод полученных данных.]]

=== Ресурс параллелизма алгоритма ===
Основной ресурс параллелизма алгоритма составляет итерационный блок. Эта последовательность итераций может быть выполнена для каждого входного вектора <math>u_i</math> независимо. Однако, в конце выполнения каждого итерационного блока имеют место последовательные вычисления - сложение значений объектной функции, полученных независимо на каждом процессоре, а также перерасчет кластерных центров.

Высота [[глоссарий#Ярусно-параллельная форма графа алгоритма|ЯПФ]] оценивается как <math>O(1)</math> (при условии, что число итераций существенно меньше объёма выборки <math>n</math>). Ширина [[глоссарий#Ярусно-параллельная форма графа алгоритма|ЯПФ]] равна <math>n</math>.

Необходимо учитывать, что при небольшом объеме входной выборки, параллельная реализация алгоритма может лишь понизить производительность. В первую очередь это связано с пересылкой данных для вычисления итоговых значений объектной функции и кластерных центров.

=== Входные и выходные данные алгоритма ===
'''Входные данные:''' матрица <math>U\in \mathbb{R}^{n\times m}</math>, представляющая собой набор векторов <math>\{u_i\}_{i=1}^{n}, u_i \in \mathbb{R}^m</math>; количество кластеров <math>C \in \mathbb{N}</math>.

'''Объём входных данных:''' <math>nm+1</math>.

'''Выходные данные:''' набор векторов - кластерных центров <math>\{c_i\}_{i=1}^{C}, c_i \in \mathbb{R}^m</math>; матрица <math>M\in \mathbb{N}^{n\times C}</math> c информацией о разбиении объектов на кластера. Элемент <math>m_{ij}=1</math>, если <math>u_j \in C_i</math>, где <math>C_i</math> содержит все объекты <math>u</math>, принадлежащие кластеру <math>i</math>. Остальные элементы <math>m_{ij}=0</math>.

'''Объём выходных данных:''' <math>(n+m)C</math>.

=== Свойства алгоритма ===
Достоинства:

* лёгкость реализации;
* вычислительная простота;
* может служить для кластеризации больших наборов числовых данных;

Недостатки:

* задание количества кластеров;
* отсутствие гарантии в нахождении оптимального решения;

Соотношение последовательной и параллельной сложности алгоритма: линейное.

Вычислительная мощность алгоритма, как отношение числа операций к суммарному объему входных и выходных данных равна константе.

Алгоритм является недетерминированным, т.к. он является итерационным с выходом по точности, а также использует датчик случайных чисел для инициализации кластерных центров.

== Программная реализация алгоритма ==
=== Масштабируемость алгоритма и его реализации ===

==== Масштабируемость алгоритма ====
==== Масштабируемость реализации алгоритма ====

=== Существующие реализации алгоритма ===
* [http://projects.jasmeet.me/2013/03/HardCMeans.html Последовательная реализация алгоритма на MatLab]
* [https://github.com/artpar/Hard-Clustering-implementation Последовательная реализация алгоритма на С++]

== Литература ==
<references />

Участник:Каледа Александр/Строгий алгоритм С средних (Hard C-Means)

2016-10-15T19:31:37Z

Каледа Александр:

{{Assignment}}

{{algorithm
| name = Строгий алгоритм С средних (Hard C-Means)
| serial_complexity = <math>O(n)</math>
| pf_height = <math>O(1)</math>
| pf_width = <math>O(n)</math>
| input_data = <math>nm+1</math>
| output_data = <math>(n+m)C</math>
}}

Авторы описания: [[Участник:Каледа_Александр|Каледа Александр]], [[Участник:Шапулин_Андрей|Шапулин Андрей]].

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===
'''Строгий алгоритм C средних''' ('''''Hard C-Means, HCM'''''; ''Jang, Sun and Mizutani, 1997'') один из наиболее широко используемых алгоритмов кластеризации данных<ref>Jan Jantzen «Neurofuzzy Modelling». Электронное издание.</ref>. Алгоритм разбивает большие наборы векторов в многомерном пространстве по заранее заданному количеству кластеров (т.е. является управляемым).

На вход алгоритму подается набор векторов и количество кластеров. Дополнительно может задаваться пороговая величина объектной функции, при достижении которой алгоритм останавливается. После окончания работы алгоритма каждый вектор будет отнесет к определенному кластерному центру. Алгоритм, являясь итерационным, зависит от начальных значений кластерных центров, а следовательно может не сходиться к локальному минимуму.

На первом шаге алгоритма происходит инициализация кластерным центров, это можно сделать выбрав случайным образом вектора из входного набора. На следующем шаге начинается итерационный процесс, завершающийся при достижении порогового значения объектной функцией или при минимальном отличии, от значения на предыдущей итерации.

Вычисления, выполняющиеся на очередной итерации алгоритма:

# Расчёт рядовой матрицы (сопоставление вектора соответствующему кластерному центру).
# Расчёт объектной функции.
# Пересчёт кластерных центров.

=== Математическое описание алгоритма ===
Исходные данные: матрица <math>U\in \mathbb{R}^{n\times m}</math>, представляющая собой набор векторов <math>\{u_i\}_{i=1}^{n}, u_i \in \mathbb{R}^m</math>; количество кластеров <math>C \in \mathbb{N}</math>.

Вычисляемые данные: набор векторов - кластерных центров <math>\{c_i\}_{i=1}^{C}, c_i \in \mathbb{R}^m</math>; матрица <math>M\in \mathbb{N}^{n\times C}</math> c информацией о разбиении объектов на кластера. Элемент <math>m_{ij}=1</math>, если <math>u_j \in C_i</math>, где <math>C_i</math> содержит все объекты <math>u</math>, принадлежащие кластеру <math>i</math>. Остальные элементы <math>m_{ij}=0</math>.

Алгоритм:

Шаг 1. Инициализация кластерных центров <math>c_i, i = 1, 2, \dots, C.</math> Это можно сделать выбрав случайным образом C векторов из входного набора <math>\{u_i\}_{i=1}^{n}</math>

Шаг 2. Вычисление рядовой матрицы M.

Матрица <math>M</math> состоит из элементов <math>M = \|m_{ik}\|</math>.

:<math>
m_{ik} = \begin{cases}
1, & \|u_k-c_i\|^2 \leqslant \|u_k-c_j\|^2 \;\; \text{for all } i \neq j; \;\; (i,j=1,2,\ldots,C; \; k = 1,2,\ldots,n)\\
0, & \text{otherwise}.
\end{cases}
</math>

Шаг 3. Расчет объектной функции:

:<math>
J = \sum\limits_{i=1}^C J_i = \sum\limits_{i=1}^C \left( \sum\limits_{k:\, u_k \in C_i} \|u_k -c_i \|^2 \right)</math>.

На этом шаге происходит остановка и выход из цикла, если полученное значение ниже пороговой величины или полученное значение не сильно отличается от значений, полученных на предыдущих циклах.

Шаг 4. Пересчет кластерных центров.

Пересчет кластерных центров выполняется в соответствии со следующим уравнением:
:<math>
c_i = \frac{1}{|C_i|} \sum\limits_{k:\, u_k \in C_i} u_k,
</math>
где <math>|C_i|</math> -- количество элементов в <math>i</math>-ом кластере.

Шаг 5. Переход на шаг 2.

Описание взято из <ref> Нейский И.М. Классификация и сравнение методов кластеризации.</ref>.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма Hard C-Means можно составить из множественных (всего их <math>nC</math>) вычислений квадратов нормы разности векторов <math>u_k</math> и кластерных центров <math>c_i</math>: <math>\|u_k-c_i\|^2</math>.

=== Макроструктура алгоритма ===
Как записано и в описании ядра алгоритма, основную часть метода составляют множественные (<math>Cn</math>) вычисления квадратов норм:

:<math>\|u_k-c_i\|^2</math>.

Также присутствуют данные вычислительные операции:

* Суммирование квадратов норм векторов:

:<math>
J = \sum\limits_{i=1}^C J_i = \sum\limits_{i=1}^C \left( \sum\limits_{k:\, u_k \in C_i} \|u_k -c_i \|^2 \right)
</math>

* Поэлементное суммирование векторов:

:<math>
c_i = \frac{1}{|C_i|} \sum\limits_{k:\, u_k \in C_i} u_k
</math>

=== Схема реализации последовательного алгоритма ===
Итерационный блок алгоритма можно описать на языке Python следующим образом:

<source lang="python3">
for i in range(n):
idx_min = 0
dist_min = ((u[i] - c[0]) ** 2).sum()

for j in range(1, C):
dist = ((u[i] - c[j]) ** 2).sum()
if dist < dist_min:
idx_min = j
dist_min = dist

M[i, idx_min] = 1
c_next[idx_min] += u[i]
c_next_cnt[idx_min] += 1
J += dist_min
</source>

=== Последовательная сложность алгоритма ===
Предполагаем, что предельная точность алгоритма достигаема менее, чем за <math>n</math> итераций. Иначе использование алгоритма можно считать нерациональным. Также предположим, что размерность <math>m</math> и количество кластерных центров <math>C</math> существенно меньше <math>n</math>.

Операция вычисления квадрата нормы разности векторов требует выполнения <math>m-1</math> арифметических операций сложения, <math>m</math> операций вычитания и <math>m</math> операций умножения.

Каждая итерация алгоритма требует выполнения:
* <math>nC</math> операций вычисления квадрата нормы разности векторов;
* <math>nC</math> операций сравнения квадрата нормы;
* <math>3n</math> операций сложения;

Таким образом, на каждой итерации имеем:
* <math>mnC</math> операций умножения;
* <math>(2mC + 3)n</math> арифметических операций сложения и вычитания;

В итоге имеем сложность последовательной реализации алгоритма <math>O(n)</math>.

=== Информационный граф ===
Граф алгоритма состоит из 4 видов вершин:

'''Первая''' группа вершин отмечена символом '''''M'''''. Ей соответствует вычисление минимального расстояния до кластерных центров, а также запись единицы в соответствующий столбец матрицы, обозначающей принадлежность кластерному центру:
* независимое вычисление расстояний от заданного элемента <math>u_i</math> до каждого из кластерных центров;
* последовательное сравнение полученных значений с целью отыскания максимума;
* операция записи 1 в соответствующий столбец матрицы принадлежности кластерным центрам;

'''Вторая''' вершина отмечена символом '''''J''''', на этом этапе происходит итоговый расчёт объектной функции.

'''Третья''' вершина помечена '''''if''''', на этом этапе происходит проверка условия достижения требуемой точности.

'''Четвертая''' соответствует операции пересчёта кластерных центров, она отмечена как '''''C'''''.

[[File:Cmeans.png|thumb|800px|center|Рисунок 1. Информационный граф алгоритма. Здесь '''''in''''' — ввод входных данных, '''''D''''' — вычисление минимального расстояния до кластерных центров и проставление принадлежности соответствующему кластерному центру, '''''J''''' — вычисление объектной функции по результатам полученных вычислений, '''''if''''' — проверка условия достижения желаемой точности, '''''C''''' — пересчёт кластерных центров и '''''out''''' — вывод полученных данных.]]

=== Ресурс параллелизма алгоритма ===
Основной ресурс параллелизма алгоритма составляет итерационный блок. Эта последовательность итераций может быть выполнена для каждого входного вектора <math>u_i</math> независимо. Однако, в конце выполнения каждого итерационного блока имеют место последовательные вычисления - сложение значений объектной функции, полученных независимо на каждом процессоре, а также перерасчет кластерных центров.

Высота [[глоссарий#Ярусно-параллельная форма графа алгоритма|ЯПФ]] оценивается как <math>O(1)</math> (при условии, что число итераций существенно меньше объёма выборки <math>n</math>). Ширина [[глоссарий#Ярусно-параллельная форма графа алгоритма|ЯПФ]] равна <math>n</math>.

Необходимо учитывать, что при небольшом объеме входной выборки, параллельная реализация алгоритма может лишь понизить производительность. В первую очередь это связано с пересылкой данных для вычисления итоговых значений объектной функции и кластерных центров.

=== Входные и выходные данные алгоритма ===
'''Входные данные:''' матрица <math>U\in \mathbb{R}^{n\times m}</math>, представляющая собой набор векторов <math>\{u_i\}_{i=1}^{n}, u_i \in \mathbb{R}^m</math>; количество кластеров <math>C \in \mathbb{N}</math>.

'''Объём входных данных:''' <math>nm+1</math>.

'''Выходные данные:''' набор векторов - кластерных центров <math>\{c_i\}_{i=1}^{C}, c_i \in \mathbb{R}^m</math>; матрица <math>M\in \mathbb{N}^{n\times C}</math> c информацией о разбиении объектов на кластера. Элемент <math>m_{ij}=1</math>, если <math>u_j \in C_i</math>, где <math>C_i</math> содержит все объекты <math>u</math>, принадлежащие кластеру <math>i</math>. Остальные элементы <math>m_{ij}=0</math>.

'''Объём выходных данных:''' <math>(n+m)C</math>.

=== Свойства алгоритма ===
Достоинства:

* лёгкость реализации;
* вычислительная простота;
* может служить для кластеризации больших наборов числовых данных;

Недостатки:

* задание количества кластеров;
* отсутствие гарантии в нахождении оптимального решения;

Соотношение последовательной и параллельной сложности алгоритма: линейное.

Вычислительная мощность алгоритма, как отношение числа операций к суммарному объему входных и выходных данных равна константе.

Алгоритм является недетерминированным, т.к. он является итерационным с выходом по точности, а также использует датчик случайных чисел для инициализации кластерных центров.

== Программная реализация алгоритма ==
=== Масштабируемость алгоритма и его реализации ===

==== Масштабируемость алгоритма ====
==== Масштабируемость реализации алгоритма ====

=== Существующие реализации алгоритма ===
* [http://projects.jasmeet.me/2013/03/HardCMeans.html Последовательная реализация алгоритма на MatLab]
* [https://github.com/artpar/Hard-Clustering-implementation Последовательная реализация алгоритма на С++]

== Литература ==
<references />

Участник:Каледа Александр/Строгий алгоритм С средних (Hard C-Means)

2016-10-15T19:31:03Z

Каледа Александр: /* Свойства алгоритма */

{{algorithm
| name = Строгий алгоритм С средних (Hard C-Means)
| serial_complexity = <math>O(n)</math>
| pf_height = <math>O(1)</math>
| pf_width = <math>O(n)</math>
| input_data = <math>nm+1</math>
| output_data = <math>(n+m)C</math>
}}

Авторы описания: [[Участник:Каледа_Александр|Каледа Александр]], [[Участник:Шапулин_Андрей|Шапулин Андрей]].

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===
'''Строгий алгоритм C средних''' ('''''Hard C-Means, HCM'''''; ''Jang, Sun and Mizutani, 1997'') один из наиболее широко используемых алгоритмов кластеризации данных<ref>Jan Jantzen «Neurofuzzy Modelling». Электронное издание.</ref>. Алгоритм разбивает большие наборы векторов в многомерном пространстве по заранее заданному количеству кластеров (т.е. является управляемым).

На вход алгоритму подается набор векторов и количество кластеров. Дополнительно может задаваться пороговая величина объектной функции, при достижении которой алгоритм останавливается. После окончания работы алгоритма каждый вектор будет отнесет к определенному кластерному центру. Алгоритм, являясь итерационным, зависит от начальных значений кластерных центров, а следовательно может не сходиться к локальному минимуму.

На первом шаге алгоритма происходит инициализация кластерным центров, это можно сделать выбрав случайным образом вектора из входного набора. На следующем шаге начинается итерационный процесс, завершающийся при достижении порогового значения объектной функцией или при минимальном отличии, от значения на предыдущей итерации.

Вычисления, выполняющиеся на очередной итерации алгоритма:

# Расчёт рядовой матрицы (сопоставление вектора соответствующему кластерному центру).
# Расчёт объектной функции.
# Пересчёт кластерных центров.

=== Математическое описание алгоритма ===
Исходные данные: матрица <math>U\in \mathbb{R}^{n\times m}</math>, представляющая собой набор векторов <math>\{u_i\}_{i=1}^{n}, u_i \in \mathbb{R}^m</math>; количество кластеров <math>C \in \mathbb{N}</math>.

Вычисляемые данные: набор векторов - кластерных центров <math>\{c_i\}_{i=1}^{C}, c_i \in \mathbb{R}^m</math>; матрица <math>M\in \mathbb{N}^{n\times C}</math> c информацией о разбиении объектов на кластера. Элемент <math>m_{ij}=1</math>, если <math>u_j \in C_i</math>, где <math>C_i</math> содержит все объекты <math>u</math>, принадлежащие кластеру <math>i</math>. Остальные элементы <math>m_{ij}=0</math>.

Алгоритм:

Шаг 1. Инициализация кластерных центров <math>c_i, i = 1, 2, \dots, C.</math> Это можно сделать выбрав случайным образом C векторов из входного набора <math>\{u_i\}_{i=1}^{n}</math>

Шаг 2. Вычисление рядовой матрицы M.

Матрица <math>M</math> состоит из элементов <math>M = \|m_{ik}\|</math>.

:<math>
m_{ik} = \begin{cases}
1, & \|u_k-c_i\|^2 \leqslant \|u_k-c_j\|^2 \;\; \text{for all } i \neq j; \;\; (i,j=1,2,\ldots,C; \; k = 1,2,\ldots,n)\\
0, & \text{otherwise}.
\end{cases}
</math>

Шаг 3. Расчет объектной функции:

:<math>
J = \sum\limits_{i=1}^C J_i = \sum\limits_{i=1}^C \left( \sum\limits_{k:\, u_k \in C_i} \|u_k -c_i \|^2 \right)</math>.

На этом шаге происходит остановка и выход из цикла, если полученное значение ниже пороговой величины или полученное значение не сильно отличается от значений, полученных на предыдущих циклах.

Шаг 4. Пересчет кластерных центров.

Пересчет кластерных центров выполняется в соответствии со следующим уравнением:
:<math>
c_i = \frac{1}{|C_i|} \sum\limits_{k:\, u_k \in C_i} u_k,
</math>
где <math>|C_i|</math> -- количество элементов в <math>i</math>-ом кластере.

Шаг 5. Переход на шаг 2.

Описание взято из <ref> Нейский И.М. Классификация и сравнение методов кластеризации.</ref>.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма Hard C-Means можно составить из множественных (всего их <math>nC</math>) вычислений квадратов нормы разности векторов <math>u_k</math> и кластерных центров <math>c_i</math>: <math>\|u_k-c_i\|^2</math>.

=== Макроструктура алгоритма ===
Как записано и в описании ядра алгоритма, основную часть метода составляют множественные (<math>Cn</math>) вычисления квадратов норм:

:<math>\|u_k-c_i\|^2</math>.

Также присутствуют данные вычислительные операции:

* Суммирование квадратов норм векторов:

:<math>
J = \sum\limits_{i=1}^C J_i = \sum\limits_{i=1}^C \left( \sum\limits_{k:\, u_k \in C_i} \|u_k -c_i \|^2 \right)
</math>

* Поэлементное суммирование векторов:

:<math>
c_i = \frac{1}{|C_i|} \sum\limits_{k:\, u_k \in C_i} u_k
</math>

=== Схема реализации последовательного алгоритма ===
Итерационный блок алгоритма можно описать на языке Python следующим образом:

<source lang="python3">
for i in range(n):
idx_min = 0
dist_min = ((u[i] - c[0]) ** 2).sum()

for j in range(1, C):
dist = ((u[i] - c[j]) ** 2).sum()
if dist < dist_min:
idx_min = j
dist_min = dist

M[i, idx_min] = 1
c_next[idx_min] += u[i]
c_next_cnt[idx_min] += 1
J += dist_min
</source>

=== Последовательная сложность алгоритма ===
Предполагаем, что предельная точность алгоритма достигаема менее, чем за <math>n</math> итераций. Иначе использование алгоритма можно считать нерациональным. Также предположим, что размерность <math>m</math> и количество кластерных центров <math>C</math> существенно меньше <math>n</math>.

Операция вычисления квадрата нормы разности векторов требует выполнения <math>m-1</math> арифметических операций сложения, <math>m</math> операций вычитания и <math>m</math> операций умножения.

Каждая итерация алгоритма требует выполнения:
* <math>nC</math> операций вычисления квадрата нормы разности векторов;
* <math>nC</math> операций сравнения квадрата нормы;
* <math>3n</math> операций сложения;

Таким образом, на каждой итерации имеем:
* <math>mnC</math> операций умножения;
* <math>(2mC + 3)n</math> арифметических операций сложения и вычитания;

В итоге имеем сложность последовательной реализации алгоритма <math>O(n)</math>.

=== Информационный граф ===
Граф алгоритма состоит из 4 видов вершин:

'''Первая''' группа вершин отмечена символом '''''M'''''. Ей соответствует вычисление минимального расстояния до кластерных центров, а также запись единицы в соответствующий столбец матрицы, обозначающей принадлежность кластерному центру:
* независимое вычисление расстояний от заданного элемента <math>u_i</math> до каждого из кластерных центров;
* последовательное сравнение полученных значений с целью отыскания максимума;
* операция записи 1 в соответствующий столбец матрицы принадлежности кластерным центрам;

'''Вторая''' вершина отмечена символом '''''J''''', на этом этапе происходит итоговый расчёт объектной функции.

'''Третья''' вершина помечена '''''if''''', на этом этапе происходит проверка условия достижения требуемой точности.

'''Четвертая''' соответствует операции пересчёта кластерных центров, она отмечена как '''''C'''''.

[[File:Cmeans.png|thumb|800px|center|Рисунок 1. Информационный граф алгоритма. Здесь '''''in''''' — ввод входных данных, '''''D''''' — вычисление минимального расстояния до кластерных центров и проставление принадлежности соответствующему кластерному центру, '''''J''''' — вычисление объектной функции по результатам полученных вычислений, '''''if''''' — проверка условия достижения желаемой точности, '''''C''''' — пересчёт кластерных центров и '''''out''''' — вывод полученных данных.]]

=== Ресурс параллелизма алгоритма ===
Основной ресурс параллелизма алгоритма составляет итерационный блок. Эта последовательность итераций может быть выполнена для каждого входного вектора <math>u_i</math> независимо. Однако, в конце выполнения каждого итерационного блока имеют место последовательные вычисления - сложение значений объектной функции, полученных независимо на каждом процессоре, а также перерасчет кластерных центров.

Высота [[глоссарий#Ярусно-параллельная форма графа алгоритма|ЯПФ]] оценивается как <math>O(1)</math> (при условии, что число итераций существенно меньше объёма выборки <math>n</math>). Ширина [[глоссарий#Ярусно-параллельная форма графа алгоритма|ЯПФ]] равна <math>n</math>.

Необходимо учитывать, что при небольшом объеме входной выборки, параллельная реализация алгоритма может лишь понизить производительность. В первую очередь это связано с пересылкой данных для вычисления итоговых значений объектной функции и кластерных центров.

=== Входные и выходные данные алгоритма ===
'''Входные данные:''' матрица <math>U\in \mathbb{R}^{n\times m}</math>, представляющая собой набор векторов <math>\{u_i\}_{i=1}^{n}, u_i \in \mathbb{R}^m</math>; количество кластеров <math>C \in \mathbb{N}</math>.

'''Объём входных данных:''' <math>nm+1</math>.

'''Выходные данные:''' набор векторов - кластерных центров <math>\{c_i\}_{i=1}^{C}, c_i \in \mathbb{R}^m</math>; матрица <math>M\in \mathbb{N}^{n\times C}</math> c информацией о разбиении объектов на кластера. Элемент <math>m_{ij}=1</math>, если <math>u_j \in C_i</math>, где <math>C_i</math> содержит все объекты <math>u</math>, принадлежащие кластеру <math>i</math>. Остальные элементы <math>m_{ij}=0</math>.

'''Объём выходных данных:''' <math>(n+m)C</math>.

=== Свойства алгоритма ===
Достоинства:

* лёгкость реализации;
* вычислительная простота;
* может служить для кластеризации больших наборов числовых данных;

Недостатки:

* задание количества кластеров;
* отсутствие гарантии в нахождении оптимального решения;

Соотношение последовательной и параллельной сложности алгоритма: линейное.

Вычислительная мощность алгоритма, как отношение числа операций к суммарному объему входных и выходных данных равна константе.

Алгоритм является недетерминированным, т.к. он является итерационным с выходом по точности, а также использует датчик случайных чисел для инициализации кластерных центров.

== Программная реализация алгоритма ==
=== Масштабируемость алгоритма и его реализации ===

==== Масштабируемость алгоритма ====
==== Масштабируемость реализации алгоритма ====

=== Существующие реализации алгоритма ===
* [http://projects.jasmeet.me/2013/03/HardCMeans.html Последовательная реализация алгоритма на MatLab]
* [https://github.com/artpar/Hard-Clustering-implementation Последовательная реализация алгоритма на С++]

== Литература ==
<references />

Участник:Каледа Александр/Строгий алгоритм С средних (Hard C-Means)

2016-10-15T18:37:19Z

Каледа Александр: /* Входные и выходные данные алгоритма */

{{algorithm
| name = Строгий алгоритм С средних (Hard C-Means)
| serial_complexity = <math>O(n)</math>
| pf_height = <math>O(1)</math>
| pf_width = <math>O(n)</math>
| input_data = <math>nm+1</math>
| output_data = <math>(n+m)C</math>
}}

Авторы описания: [[Участник:Каледа_Александр|Каледа Александр]], [[Участник:Шапулин_Андрей|Шапулин Андрей]].

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===
'''Строгий алгоритм C средних''' ('''''Hard C-Means, HCM'''''; ''Jang, Sun and Mizutani, 1997'') один из наиболее широко используемых алгоритмов кластеризации данных<ref>Jan Jantzen «Neurofuzzy Modelling». Электронное издание.</ref>. Алгоритм разбивает большие наборы векторов в многомерном пространстве по заранее заданному количеству кластеров (т.е. является управляемым).

На вход алгоритму подается набор векторов и количество кластеров. Дополнительно может задаваться пороговая величина объектной функции, при достижении которой алгоритм останавливается. После окончания работы алгоритма каждый вектор будет отнесет к определенному кластерному центру. Алгоритм, являясь итерационным, зависит от начальных значений кластерных центров, а следовательно может не сходиться к локальному минимуму.

На первом шаге алгоритма происходит инициализация кластерным центров, это можно сделать выбрав случайным образом вектора из входного набора. На следующем шаге начинается итерационный процесс, завершающийся при достижении порогового значения объектной функцией или при минимальном отличии, от значения на предыдущей итерации.

Вычисления, выполняющиеся на очередной итерации алгоритма:

# Расчёт рядовой матрицы (сопоставление вектора соответствующему кластерному центру).
# Расчёт объектной функции.
# Пересчёт кластерных центров.

=== Математическое описание алгоритма ===
Исходные данные: матрица <math>U\in \mathbb{R}^{n\times m}</math>, представляющая собой набор векторов <math>\{u_i\}_{i=1}^{n}, u_i \in \mathbb{R}^m</math>; количество кластеров <math>C \in \mathbb{N}</math>.

Вычисляемые данные: набор векторов - кластерных центров <math>\{c_i\}_{i=1}^{C}, c_i \in \mathbb{R}^m</math>; матрица <math>M\in \mathbb{N}^{n\times C}</math> c информацией о разбиении объектов на кластера. Элемент <math>m_{ij}=1</math>, если <math>u_j \in C_i</math>, где <math>C_i</math> содержит все объекты <math>u</math>, принадлежащие кластеру <math>i</math>. Остальные элементы <math>m_{ij}=0</math>.

Алгоритм:

Шаг 1. Инициализация кластерных центров <math>c_i, i = 1, 2, \dots, C.</math> Это можно сделать выбрав случайным образом C векторов из входного набора <math>\{u_i\}_{i=1}^{n}</math>

Шаг 2. Вычисление рядовой матрицы M.

Матрица <math>M</math> состоит из элементов <math>M = \|m_{ik}\|</math>.

:<math>
m_{ik} = \begin{cases}
1, & \|u_k-c_i\|^2 \leqslant \|u_k-c_j\|^2 \;\; \text{for all } i \neq j; \;\; (i,j=1,2,\ldots,C; \; k = 1,2,\ldots,n)\\
0, & \text{otherwise}.
\end{cases}
</math>

Шаг 3. Расчет объектной функции:

:<math>
J = \sum\limits_{i=1}^C J_i = \sum\limits_{i=1}^C \left( \sum\limits_{k:\, u_k \in C_i} \|u_k -c_i \|^2 \right)</math>.

На этом шаге происходит остановка и выход из цикла, если полученное значение ниже пороговой величины или полученное значение не сильно отличается от значений, полученных на предыдущих циклах.

Шаг 4. Пересчет кластерных центров.

Пересчет кластерных центров выполняется в соответствии со следующим уравнением:
:<math>
c_i = \frac{1}{|C_i|} \sum\limits_{k:\, u_k \in C_i} u_k,
</math>
где <math>|C_i|</math> -- количество элементов в <math>i</math>-ом кластере.

Шаг 5. Переход на шаг 2.

Описание взято из <ref> Нейский И.М. Классификация и сравнение методов кластеризации.</ref>.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма Hard C-Means можно составить из множественных (всего их <math>nC</math>) вычислений квадратов нормы разности векторов <math>u_k</math> и кластерных центров <math>c_i</math>: <math>\|u_k-c_i\|^2</math>.

=== Макроструктура алгоритма ===
Как записано и в описании ядра алгоритма, основную часть метода составляют множественные (<math>Cn</math>) вычисления квадратов норм:

:<math>\|u_k-c_i\|^2</math>.

Также присутствуют данные вычислительные операции:

* Суммирование квадратов норм векторов:

:<math>
J = \sum\limits_{i=1}^C J_i = \sum\limits_{i=1}^C \left( \sum\limits_{k:\, u_k \in C_i} \|u_k -c_i \|^2 \right)
</math>

* Поэлементное суммирование векторов:

:<math>
c_i = \frac{1}{|C_i|} \sum\limits_{k:\, u_k \in C_i} u_k
</math>

=== Схема реализации последовательного алгоритма ===
Итерационный блок алгоритма можно описать на языке Python следующим образом:

<source lang="python3">
for i in range(n):
idx_min = 0
dist_min = ((u[i] - c[0]) ** 2).sum()

for j in range(1, C):
dist = ((u[i] - c[j]) ** 2).sum()
if dist < dist_min:
idx_min = j
dist_min = dist

M[i, idx_min] = 1
c_next[idx_min] += u[i]
c_next_cnt[idx_min] += 1
J += dist_min
</source>

=== Последовательная сложность алгоритма ===
Предполагаем, что предельная точность алгоритма достигаема менее, чем за <math>n</math> итераций. Иначе использование алгоритма можно считать нерациональным. Также предположим, что размерность <math>m</math> и количество кластерных центров <math>C</math> существенно меньше <math>n</math>.

Операция вычисления квадрата нормы разности векторов требует выполнения <math>m-1</math> арифметических операций сложения, <math>m</math> операций вычитания и <math>m</math> операций умножения.

Каждая итерация алгоритма требует выполнения:
* <math>nC</math> операций вычисления квадрата нормы разности векторов;
* <math>nC</math> операций сравнения квадрата нормы;
* <math>3n</math> операций сложения;

Таким образом, на каждой итерации имеем:
* <math>mnC</math> операций умножения;
* <math>(2mC + 3)n</math> арифметических операций сложения и вычитания;

В итоге имеем сложность последовательной реализации алгоритма <math>O(n)</math>.

=== Информационный граф ===
Граф алгоритма состоит из 4 видов вершин:

'''Первая''' группа вершин отмечена символом '''''M'''''. Ей соответствует вычисление минимального расстояния до кластерных центров, а также запись единицы в соответствующий столбец матрицы, обозначающей принадлежность кластерному центру:
* независимое вычисление расстояний от заданного элемента <math>u_i</math> до каждого из кластерных центров;
* последовательное сравнение полученных значений с целью отыскания максимума;
* операция записи 1 в соответствующий столбец матрицы принадлежности кластерным центрам;

'''Вторая''' вершина отмечена символом '''''J''''', на этом этапе происходит итоговый расчёт объектной функции.

'''Третья''' вершина помечена '''''if''''', на этом этапе происходит проверка условия достижения требуемой точности.

'''Четвертая''' соответствует операции пересчёта кластерных центров, она отмечена как '''''C'''''.

[[File:Cmeans.png|thumb|800px|center|Рисунок 1. Информационный граф алгоритма. Здесь '''''in''''' — ввод входных данных, '''''D''''' — вычисление минимального расстояния до кластерных центров и проставление принадлежности соответствующему кластерному центру, '''''J''''' — вычисление объектной функции по результатам полученных вычислений, '''''if''''' — проверка условия достижения желаемой точности, '''''C''''' — пересчёт кластерных центров и '''''out''''' — вывод полученных данных.]]

=== Ресурс параллелизма алгоритма ===
Основной ресурс параллелизма алгоритма составляет итерационный блок. Эта последовательность итераций может быть выполнена для каждого входного вектора <math>u_i</math> независимо. Однако, в конце выполнения каждого итерационного блока имеют место последовательные вычисления - сложение значений объектной функции, полученных независимо на каждом процессоре, а также перерасчет кластерных центров.

Высота [[глоссарий#Ярусно-параллельная форма графа алгоритма|ЯПФ]] оценивается как <math>O(1)</math> (при условии, что число итераций существенно меньше объёма выборки <math>n</math>). Ширина [[глоссарий#Ярусно-параллельная форма графа алгоритма|ЯПФ]] равна <math>n</math>.

Необходимо учитывать, что при небольшом объеме входной выборки, параллельная реализация алгоритма может лишь понизить производительность. В первую очередь это связано с пересылкой данных для вычисления итоговых значений объектной функции и кластерных центров.

=== Входные и выходные данные алгоритма ===
'''Входные данные:''' матрица <math>U\in \mathbb{R}^{n\times m}</math>, представляющая собой набор векторов <math>\{u_i\}_{i=1}^{n}, u_i \in \mathbb{R}^m</math>; количество кластеров <math>C \in \mathbb{N}</math>.

'''Объём входных данных:''' <math>nm+1</math>.

'''Выходные данные:''' набор векторов - кластерных центров <math>\{c_i\}_{i=1}^{C}, c_i \in \mathbb{R}^m</math>; матрица <math>M\in \mathbb{N}^{n\times C}</math> c информацией о разбиении объектов на кластера. Элемент <math>m_{ij}=1</math>, если <math>u_j \in C_i</math>, где <math>C_i</math> содержит все объекты <math>u</math>, принадлежащие кластеру <math>i</math>. Остальные элементы <math>m_{ij}=0</math>.

'''Объём выходных данных:''' <math>(n+m)C</math>.

=== Свойства алгоритма ===
Достоинства:

* лёгкость реализации;
* вычислительная простота;
* может служить для кластеризации больших наборов числовых данных;

Недостатки:

* задание количества кластеров;
* отсутствие гарантии в нахождении оптимального решения;

Соотношение последовательной и параллельной сложности алгоритма: ???

Вычислительная мощность алгоритма, как отношение числа операций к суммарному объему входных и выходных данных равна константе.

Алгоритм является недетерменированным, т.к. он является итерационным с выходом по точности, а также использует датчик случайных чисел для инициализации кластерных центров.

Степень исхода вершины информационного графа ???

"Длинные" дуги в информационном графе ???

== Программная реализация алгоритма ==
=== Масштабируемость алгоритма и его реализации ===

==== Масштабируемость алгоритма ====
==== Масштабируемость реализации алгоритма ====

=== Существующие реализации алгоритма ===
* [http://projects.jasmeet.me/2013/03/HardCMeans.html Последовательная реализация алгоритма на MatLab]
* [https://github.com/artpar/Hard-Clustering-implementation Последовательная реализация алгоритма на С++]

== Литература ==
<references />

Участник:Каледа Александр/Строгий алгоритм С средних (Hard C-Means)

2016-10-15T18:36:10Z

Каледа Александр: /* Входные и выходные данные алгоритма */

{{algorithm
| name = Строгий алгоритм С средних (Hard C-Means)
| serial_complexity = <math>O(n)</math>
| pf_height = <math>O(1)</math>
| pf_width = <math>O(n)</math>
| input_data = <math>nm+1</math>
| output_data = <math>(n+m)C</math>
}}

Авторы описания: [[Участник:Каледа_Александр|Каледа Александр]], [[Участник:Шапулин_Андрей|Шапулин Андрей]].

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===
'''Строгий алгоритм C средних''' ('''''Hard C-Means, HCM'''''; ''Jang, Sun and Mizutani, 1997'') один из наиболее широко используемых алгоритмов кластеризации данных<ref>Jan Jantzen «Neurofuzzy Modelling». Электронное издание.</ref>. Алгоритм разбивает большие наборы векторов в многомерном пространстве по заранее заданному количеству кластеров (т.е. является управляемым).

На вход алгоритму подается набор векторов и количество кластеров. Дополнительно может задаваться пороговая величина объектной функции, при достижении которой алгоритм останавливается. После окончания работы алгоритма каждый вектор будет отнесет к определенному кластерному центру. Алгоритм, являясь итерационным, зависит от начальных значений кластерных центров, а следовательно может не сходиться к локальному минимуму.

На первом шаге алгоритма происходит инициализация кластерным центров, это можно сделать выбрав случайным образом вектора из входного набора. На следующем шаге начинается итерационный процесс, завершающийся при достижении порогового значения объектной функцией или при минимальном отличии, от значения на предыдущей итерации.

Вычисления, выполняющиеся на очередной итерации алгоритма:

# Расчёт рядовой матрицы (сопоставление вектора соответствующему кластерному центру).
# Расчёт объектной функции.
# Пересчёт кластерных центров.

=== Математическое описание алгоритма ===
Исходные данные: матрица <math>U\in \mathbb{R}^{n\times m}</math>, представляющая собой набор векторов <math>\{u_i\}_{i=1}^{n}, u_i \in \mathbb{R}^m</math>; количество кластеров <math>C \in \mathbb{N}</math>.

Вычисляемые данные: набор векторов - кластерных центров <math>\{c_i\}_{i=1}^{C}, c_i \in \mathbb{R}^m</math>; матрица <math>M\in \mathbb{N}^{n\times C}</math> c информацией о разбиении объектов на кластера. Элемент <math>m_{ij}=1</math>, если <math>u_j \in C_i</math>, где <math>C_i</math> содержит все объекты <math>u</math>, принадлежащие кластеру <math>i</math>. Остальные элементы <math>m_{ij}=0</math>.

Алгоритм:

Шаг 1. Инициализация кластерных центров <math>c_i, i = 1, 2, \dots, C.</math> Это можно сделать выбрав случайным образом C векторов из входного набора <math>\{u_i\}_{i=1}^{n}</math>

Шаг 2. Вычисление рядовой матрицы M.

Матрица <math>M</math> состоит из элементов <math>M = \|m_{ik}\|</math>.

:<math>
m_{ik} = \begin{cases}
1, & \|u_k-c_i\|^2 \leqslant \|u_k-c_j\|^2 \;\; \text{for all } i \neq j; \;\; (i,j=1,2,\ldots,C; \; k = 1,2,\ldots,n)\\
0, & \text{otherwise}.
\end{cases}
</math>

Шаг 3. Расчет объектной функции:

:<math>
J = \sum\limits_{i=1}^C J_i = \sum\limits_{i=1}^C \left( \sum\limits_{k:\, u_k \in C_i} \|u_k -c_i \|^2 \right)</math>.

На этом шаге происходит остановка и выход из цикла, если полученное значение ниже пороговой величины или полученное значение не сильно отличается от значений, полученных на предыдущих циклах.

Шаг 4. Пересчет кластерных центров.

Пересчет кластерных центров выполняется в соответствии со следующим уравнением:
:<math>
c_i = \frac{1}{|C_i|} \sum\limits_{k:\, u_k \in C_i} u_k,
</math>
где <math>|C_i|</math> -- количество элементов в <math>i</math>-ом кластере.

Шаг 5. Переход на шаг 2.

Описание взято из <ref> Нейский И.М. Классификация и сравнение методов кластеризации.</ref>.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма Hard C-Means можно составить из множественных (всего их <math>nC</math>) вычислений квадратов нормы разности векторов <math>u_k</math> и кластерных центров <math>c_i</math>: <math>\|u_k-c_i\|^2</math>.

=== Макроструктура алгоритма ===
Как записано и в описании ядра алгоритма, основную часть метода составляют множественные (<math>Cn</math>) вычисления квадратов норм:

:<math>\|u_k-c_i\|^2</math>.

Также присутствуют данные вычислительные операции:

* Суммирование квадратов норм векторов:

:<math>
J = \sum\limits_{i=1}^C J_i = \sum\limits_{i=1}^C \left( \sum\limits_{k:\, u_k \in C_i} \|u_k -c_i \|^2 \right)
</math>

* Поэлементное суммирование векторов:

:<math>
c_i = \frac{1}{|C_i|} \sum\limits_{k:\, u_k \in C_i} u_k
</math>

=== Схема реализации последовательного алгоритма ===
Итерационный блок алгоритма можно описать на языке Python следующим образом:

<source lang="python3">
for i in range(n):
idx_min = 0
dist_min = ((u[i] - c[0]) ** 2).sum()

for j in range(1, C):
dist = ((u[i] - c[j]) ** 2).sum()
if dist < dist_min:
idx_min = j
dist_min = dist

M[i, idx_min] = 1
c_next[idx_min] += u[i]
c_next_cnt[idx_min] += 1
J += dist_min
</source>

=== Последовательная сложность алгоритма ===
Предполагаем, что предельная точность алгоритма достигаема менее, чем за <math>n</math> итераций. Иначе использование алгоритма можно считать нерациональным. Также предположим, что размерность <math>m</math> и количество кластерных центров <math>C</math> существенно меньше <math>n</math>.

Операция вычисления квадрата нормы разности векторов требует выполнения <math>m-1</math> арифметических операций сложения, <math>m</math> операций вычитания и <math>m</math> операций умножения.

Каждая итерация алгоритма требует выполнения:
* <math>nC</math> операций вычисления квадрата нормы разности векторов;
* <math>nC</math> операций сравнения квадрата нормы;
* <math>3n</math> операций сложения;

Таким образом, на каждой итерации имеем:
* <math>mnC</math> операций умножения;
* <math>(2mC + 3)n</math> арифметических операций сложения и вычитания;

В итоге имеем сложность последовательной реализации алгоритма <math>O(n)</math>.

=== Информационный граф ===
Граф алгоритма состоит из 4 видов вершин:

'''Первая''' группа вершин отмечена символом '''''M'''''. Ей соответствует вычисление минимального расстояния до кластерных центров, а также запись единицы в соответствующий столбец матрицы, обозначающей принадлежность кластерному центру:
* независимое вычисление расстояний от заданного элемента <math>u_i</math> до каждого из кластерных центров;
* последовательное сравнение полученных значений с целью отыскания максимума;
* операция записи 1 в соответствующий столбец матрицы принадлежности кластерным центрам;

'''Вторая''' вершина отмечена символом '''''J''''', на этом этапе происходит итоговый расчёт объектной функции.

'''Третья''' вершина помечена '''''if''''', на этом этапе происходит проверка условия достижения требуемой точности.

'''Четвертая''' соответствует операции пересчёта кластерных центров, она отмечена как '''''C'''''.

[[File:Cmeans.png|thumb|800px|center|Рисунок 1. Информационный граф алгоритма. Здесь '''''in''''' — ввод входных данных, '''''D''''' — вычисление минимального расстояния до кластерных центров и проставление принадлежности соответствующему кластерному центру, '''''J''''' — вычисление объектной функции по результатам полученных вычислений, '''''if''''' — проверка условия достижения желаемой точности, '''''C''''' — пересчёт кластерных центров и '''''out''''' — вывод полученных данных.]]

=== Ресурс параллелизма алгоритма ===
Основной ресурс параллелизма алгоритма составляет итерационный блок. Эта последовательность итераций может быть выполнена для каждого входного вектора <math>u_i</math> независимо. Однако, в конце выполнения каждого итерационного блока имеют место последовательные вычисления - сложение значений объектной функции, полученных независимо на каждом процессоре, а также перерасчет кластерных центров.

Высота [[глоссарий#Ярусно-параллельная форма графа алгоритма|ЯПФ]] оценивается как <math>O(1)</math> (при условии, что число итераций существенно меньше объёма выборки <math>n</math>). Ширина [[глоссарий#Ярусно-параллельная форма графа алгоритма|ЯПФ]] равна <math>n</math>.

Необходимо учитывать, что при небольшом объеме входной выборки, параллельная реализация алгоритма может лишь понизить производительность. В первую очередь это связано с пересылкой данных для вычисления итоговых значений объектной функции и кластерных центров.

=== Входные и выходные данные алгоритма ===
'''Входные данные:''' матрица <math>U\in \mathbb{R}^{n\times m}</math>, представляющая собой набор векторов <math>\{u_i\}_{i=1}^{n}, u_i \in \mathbb{R}^m</math>; количество кластеров <math>C \in \mathbb{N}</math>.

'''Объём входных данных:''' <math>nm+1</math>.

'''Выходные данные:''' набор векторов - кластерных центров <math>\{c_i\}_{i=1}^{C}, c_i \in \mathbb{R}^m</math>; матрица <math>M\in \mathbb{N}^{n\times C}</math> c информацией о разбиении объектов на кластера. Элемент <math>m_{ij}=1</math>, если <math>u_j \in C_i</math>, где <math>C_i</math> содержит все объекты <math>u</math>, принадлежащие кластеру <math>i</math>. Остальные элементы <math>m_{ij}=0</math>.

'''Объём выходных данных:''' <math>С(n+m)</math>.

=== Свойства алгоритма ===
Достоинства:

* лёгкость реализации;
* вычислительная простота;
* может служить для кластеризации больших наборов числовых данных;

Недостатки:

* задание количества кластеров;
* отсутствие гарантии в нахождении оптимального решения;

Соотношение последовательной и параллельной сложности алгоритма: ???

Вычислительная мощность алгоритма, как отношение числа операций к суммарному объему входных и выходных данных равна константе.

Алгоритм является недетерменированным, т.к. он является итерационным с выходом по точности, а также использует датчик случайных чисел для инициализации кластерных центров.

Степень исхода вершины информационного графа ???

"Длинные" дуги в информационном графе ???

== Программная реализация алгоритма ==
=== Масштабируемость алгоритма и его реализации ===

==== Масштабируемость алгоритма ====
==== Масштабируемость реализации алгоритма ====

=== Существующие реализации алгоритма ===
* [http://projects.jasmeet.me/2013/03/HardCMeans.html Последовательная реализация алгоритма на MatLab]
* [https://github.com/artpar/Hard-Clustering-implementation Последовательная реализация алгоритма на С++]

== Литература ==
<references />

Участник:Каледа Александр/Строгий алгоритм С средних (Hard C-Means)

2016-10-15T18:35:40Z

Каледа Александр: /* Входные и выходные данные алгоритма */

{{algorithm
| name = Строгий алгоритм С средних (Hard C-Means)
| serial_complexity = <math>O(n)</math>
| pf_height = <math>O(1)</math>
| pf_width = <math>O(n)</math>
| input_data = <math>nm+1</math>
| output_data = <math>(n+m)C</math>
}}

Авторы описания: [[Участник:Каледа_Александр|Каледа Александр]], [[Участник:Шапулин_Андрей|Шапулин Андрей]].

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===
'''Строгий алгоритм C средних''' ('''''Hard C-Means, HCM'''''; ''Jang, Sun and Mizutani, 1997'') один из наиболее широко используемых алгоритмов кластеризации данных<ref>Jan Jantzen «Neurofuzzy Modelling». Электронное издание.</ref>. Алгоритм разбивает большие наборы векторов в многомерном пространстве по заранее заданному количеству кластеров (т.е. является управляемым).

На вход алгоритму подается набор векторов и количество кластеров. Дополнительно может задаваться пороговая величина объектной функции, при достижении которой алгоритм останавливается. После окончания работы алгоритма каждый вектор будет отнесет к определенному кластерному центру. Алгоритм, являясь итерационным, зависит от начальных значений кластерных центров, а следовательно может не сходиться к локальному минимуму.

На первом шаге алгоритма происходит инициализация кластерным центров, это можно сделать выбрав случайным образом вектора из входного набора. На следующем шаге начинается итерационный процесс, завершающийся при достижении порогового значения объектной функцией или при минимальном отличии, от значения на предыдущей итерации.

Вычисления, выполняющиеся на очередной итерации алгоритма:

# Расчёт рядовой матрицы (сопоставление вектора соответствующему кластерному центру).
# Расчёт объектной функции.
# Пересчёт кластерных центров.

=== Математическое описание алгоритма ===
Исходные данные: матрица <math>U\in \mathbb{R}^{n\times m}</math>, представляющая собой набор векторов <math>\{u_i\}_{i=1}^{n}, u_i \in \mathbb{R}^m</math>; количество кластеров <math>C \in \mathbb{N}</math>.

Вычисляемые данные: набор векторов - кластерных центров <math>\{c_i\}_{i=1}^{C}, c_i \in \mathbb{R}^m</math>; матрица <math>M\in \mathbb{N}^{n\times C}</math> c информацией о разбиении объектов на кластера. Элемент <math>m_{ij}=1</math>, если <math>u_j \in C_i</math>, где <math>C_i</math> содержит все объекты <math>u</math>, принадлежащие кластеру <math>i</math>. Остальные элементы <math>m_{ij}=0</math>.

Алгоритм:

Шаг 1. Инициализация кластерных центров <math>c_i, i = 1, 2, \dots, C.</math> Это можно сделать выбрав случайным образом C векторов из входного набора <math>\{u_i\}_{i=1}^{n}</math>

Шаг 2. Вычисление рядовой матрицы M.

Матрица <math>M</math> состоит из элементов <math>M = \|m_{ik}\|</math>.

:<math>
m_{ik} = \begin{cases}
1, & \|u_k-c_i\|^2 \leqslant \|u_k-c_j\|^2 \;\; \text{for all } i \neq j; \;\; (i,j=1,2,\ldots,C; \; k = 1,2,\ldots,n)\\
0, & \text{otherwise}.
\end{cases}
</math>

Шаг 3. Расчет объектной функции:

:<math>
J = \sum\limits_{i=1}^C J_i = \sum\limits_{i=1}^C \left( \sum\limits_{k:\, u_k \in C_i} \|u_k -c_i \|^2 \right)</math>.

На этом шаге происходит остановка и выход из цикла, если полученное значение ниже пороговой величины или полученное значение не сильно отличается от значений, полученных на предыдущих циклах.

Шаг 4. Пересчет кластерных центров.

Пересчет кластерных центров выполняется в соответствии со следующим уравнением:
:<math>
c_i = \frac{1}{|C_i|} \sum\limits_{k:\, u_k \in C_i} u_k,
</math>
где <math>|C_i|</math> -- количество элементов в <math>i</math>-ом кластере.

Шаг 5. Переход на шаг 2.

Описание взято из <ref> Нейский И.М. Классификация и сравнение методов кластеризации.</ref>.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма Hard C-Means можно составить из множественных (всего их <math>nC</math>) вычислений квадратов нормы разности векторов <math>u_k</math> и кластерных центров <math>c_i</math>: <math>\|u_k-c_i\|^2</math>.

=== Макроструктура алгоритма ===
Как записано и в описании ядра алгоритма, основную часть метода составляют множественные (<math>Cn</math>) вычисления квадратов норм:

:<math>\|u_k-c_i\|^2</math>.

Также присутствуют данные вычислительные операции:

* Суммирование квадратов норм векторов:

:<math>
J = \sum\limits_{i=1}^C J_i = \sum\limits_{i=1}^C \left( \sum\limits_{k:\, u_k \in C_i} \|u_k -c_i \|^2 \right)
</math>

* Поэлементное суммирование векторов:

:<math>
c_i = \frac{1}{|C_i|} \sum\limits_{k:\, u_k \in C_i} u_k
</math>

=== Схема реализации последовательного алгоритма ===
Итерационный блок алгоритма можно описать на языке Python следующим образом:

<source lang="python3">
for i in range(n):
idx_min = 0
dist_min = ((u[i] - c[0]) ** 2).sum()

for j in range(1, C):
dist = ((u[i] - c[j]) ** 2).sum()
if dist < dist_min:
idx_min = j
dist_min = dist

M[i, idx_min] = 1
c_next[idx_min] += u[i]
c_next_cnt[idx_min] += 1
J += dist_min
</source>

=== Последовательная сложность алгоритма ===
Предполагаем, что предельная точность алгоритма достигаема менее, чем за <math>n</math> итераций. Иначе использование алгоритма можно считать нерациональным. Также предположим, что размерность <math>m</math> и количество кластерных центров <math>C</math> существенно меньше <math>n</math>.

Операция вычисления квадрата нормы разности векторов требует выполнения <math>m-1</math> арифметических операций сложения, <math>m</math> операций вычитания и <math>m</math> операций умножения.

Каждая итерация алгоритма требует выполнения:
* <math>nC</math> операций вычисления квадрата нормы разности векторов;
* <math>nC</math> операций сравнения квадрата нормы;
* <math>3n</math> операций сложения;

Таким образом, на каждой итерации имеем:
* <math>mnC</math> операций умножения;
* <math>(2mC + 3)n</math> арифметических операций сложения и вычитания;

В итоге имеем сложность последовательной реализации алгоритма <math>O(n)</math>.

=== Информационный граф ===
Граф алгоритма состоит из 4 видов вершин:

'''Первая''' группа вершин отмечена символом '''''M'''''. Ей соответствует вычисление минимального расстояния до кластерных центров, а также запись единицы в соответствующий столбец матрицы, обозначающей принадлежность кластерному центру:
* независимое вычисление расстояний от заданного элемента <math>u_i</math> до каждого из кластерных центров;
* последовательное сравнение полученных значений с целью отыскания максимума;
* операция записи 1 в соответствующий столбец матрицы принадлежности кластерным центрам;

'''Вторая''' вершина отмечена символом '''''J''''', на этом этапе происходит итоговый расчёт объектной функции.

'''Третья''' вершина помечена '''''if''''', на этом этапе происходит проверка условия достижения требуемой точности.

'''Четвертая''' соответствует операции пересчёта кластерных центров, она отмечена как '''''C'''''.

[[File:Cmeans.png|thumb|800px|center|Рисунок 1. Информационный граф алгоритма. Здесь '''''in''''' — ввод входных данных, '''''D''''' — вычисление минимального расстояния до кластерных центров и проставление принадлежности соответствующему кластерному центру, '''''J''''' — вычисление объектной функции по результатам полученных вычислений, '''''if''''' — проверка условия достижения желаемой точности, '''''C''''' — пересчёт кластерных центров и '''''out''''' — вывод полученных данных.]]

=== Ресурс параллелизма алгоритма ===
Основной ресурс параллелизма алгоритма составляет итерационный блок. Эта последовательность итераций может быть выполнена для каждого входного вектора <math>u_i</math> независимо. Однако, в конце выполнения каждого итерационного блока имеют место последовательные вычисления - сложение значений объектной функции, полученных независимо на каждом процессоре, а также перерасчет кластерных центров.

Высота [[глоссарий#Ярусно-параллельная форма графа алгоритма|ЯПФ]] оценивается как <math>O(1)</math> (при условии, что число итераций существенно меньше объёма выборки <math>n</math>). Ширина [[глоссарий#Ярусно-параллельная форма графа алгоритма|ЯПФ]] равна <math>n</math>.

Необходимо учитывать, что при небольшом объеме входной выборки, параллельная реализация алгоритма может лишь понизить производительность. В первую очередь это связано с пересылкой данных для вычисления итоговых значений объектной функции и кластерных центров.

=== Входные и выходные данные алгоритма ===
'''Входные данные:''' матрица <math>U\in \mathbb{R}^{n\times m}</math>, представляющая собой набор векторов <math>\{u_i\}_{i=1}^{n}, u_i \in \mathbb{R}^m</math>; количество кластеров <math>C \in \mathbb{N}</math>.

'''Объём входных данных:''' <math>nm+1</math>.

'''Выходные данные:''' набор векторов - кластерных центров <math>\{c_i\}_{i=1}^{C}, c_i \in \mathbb{R}^m</math>; матрица <math>M\in \mathbb{N}^{n\times C}</math> c информацией о разбиении объектов на кластера. Элемент <math>m_{ij}=1</math>, если <math>u_j \in C_i</math>, где <math>C_i</math> содержит все объекты <math>u</math>, принадлежащие кластеру <math>i</math. Остальные элементы <math>m_{ij}=0</math>.

'''Объём выходных данных:''' <math>С(n+m)</math>.

=== Свойства алгоритма ===
Достоинства:

* лёгкость реализации;
* вычислительная простота;
* может служить для кластеризации больших наборов числовых данных;

Недостатки:

* задание количества кластеров;
* отсутствие гарантии в нахождении оптимального решения;

Соотношение последовательной и параллельной сложности алгоритма: ???

Вычислительная мощность алгоритма, как отношение числа операций к суммарному объему входных и выходных данных равна константе.

Алгоритм является недетерменированным, т.к. он является итерационным с выходом по точности, а также использует датчик случайных чисел для инициализации кластерных центров.

Степень исхода вершины информационного графа ???

"Длинные" дуги в информационном графе ???

== Программная реализация алгоритма ==
=== Масштабируемость алгоритма и его реализации ===

==== Масштабируемость алгоритма ====
==== Масштабируемость реализации алгоритма ====

=== Существующие реализации алгоритма ===
* [http://projects.jasmeet.me/2013/03/HardCMeans.html Последовательная реализация алгоритма на MatLab]
* [https://github.com/artpar/Hard-Clustering-implementation Последовательная реализация алгоритма на С++]

== Литература ==
<references />

Участник:Каледа Александр/Строгий алгоритм С средних (Hard C-Means)

2016-10-15T18:33:27Z

Каледа Александр: /* Входные и выходные данные алгоритма */

{{algorithm
| name = Строгий алгоритм С средних (Hard C-Means)
| serial_complexity = <math>O(n)</math>
| pf_height = <math>O(1)</math>
| pf_width = <math>O(n)</math>
| input_data = <math>nm+1</math>
| output_data = <math>(n+m)C</math>
}}

Авторы описания: [[Участник:Каледа_Александр|Каледа Александр]], [[Участник:Шапулин_Андрей|Шапулин Андрей]].

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===
'''Строгий алгоритм C средних''' ('''''Hard C-Means, HCM'''''; ''Jang, Sun and Mizutani, 1997'') один из наиболее широко используемых алгоритмов кластеризации данных<ref>Jan Jantzen «Neurofuzzy Modelling». Электронное издание.</ref>. Алгоритм разбивает большие наборы векторов в многомерном пространстве по заранее заданному количеству кластеров (т.е. является управляемым).

На вход алгоритму подается набор векторов и количество кластеров. Дополнительно может задаваться пороговая величина объектной функции, при достижении которой алгоритм останавливается. После окончания работы алгоритма каждый вектор будет отнесет к определенному кластерному центру. Алгоритм, являясь итерационным, зависит от начальных значений кластерных центров, а следовательно может не сходиться к локальному минимуму.

На первом шаге алгоритма происходит инициализация кластерным центров, это можно сделать выбрав случайным образом вектора из входного набора. На следующем шаге начинается итерационный процесс, завершающийся при достижении порогового значения объектной функцией или при минимальном отличии, от значения на предыдущей итерации.

Вычисления, выполняющиеся на очередной итерации алгоритма:

# Расчёт рядовой матрицы (сопоставление вектора соответствующему кластерному центру).
# Расчёт объектной функции.
# Пересчёт кластерных центров.

=== Математическое описание алгоритма ===
Исходные данные: матрица <math>U\in \mathbb{R}^{n\times m}</math>, представляющая собой набор векторов <math>\{u_i\}_{i=1}^{n}, u_i \in \mathbb{R}^m</math>; количество кластеров <math>C \in \mathbb{N}</math>.

Вычисляемые данные: набор векторов - кластерных центров <math>\{c_i\}_{i=1}^{C}, c_i \in \mathbb{R}^m</math>; матрица <math>M\in \mathbb{N}^{n\times C}</math> c информацией о разбиении объектов на кластера. Элемент <math>m_{ij}=1</math>, если <math>u_j \in C_i</math>, где <math>C_i</math> содержит все объекты <math>u</math>, принадлежащие кластеру <math>i</math>. Остальные элементы <math>m_{ij}=0</math>.

Алгоритм:

Шаг 1. Инициализация кластерных центров <math>c_i, i = 1, 2, \dots, C.</math> Это можно сделать выбрав случайным образом C векторов из входного набора <math>\{u_i\}_{i=1}^{n}</math>

Шаг 2. Вычисление рядовой матрицы M.

Матрица <math>M</math> состоит из элементов <math>M = \|m_{ik}\|</math>.

:<math>
m_{ik} = \begin{cases}
1, & \|u_k-c_i\|^2 \leqslant \|u_k-c_j\|^2 \;\; \text{for all } i \neq j; \;\; (i,j=1,2,\ldots,C; \; k = 1,2,\ldots,n)\\
0, & \text{otherwise}.
\end{cases}
</math>

Шаг 3. Расчет объектной функции:

:<math>
J = \sum\limits_{i=1}^C J_i = \sum\limits_{i=1}^C \left( \sum\limits_{k:\, u_k \in C_i} \|u_k -c_i \|^2 \right)</math>.

На этом шаге происходит остановка и выход из цикла, если полученное значение ниже пороговой величины или полученное значение не сильно отличается от значений, полученных на предыдущих циклах.

Шаг 4. Пересчет кластерных центров.

Пересчет кластерных центров выполняется в соответствии со следующим уравнением:
:<math>
c_i = \frac{1}{|C_i|} \sum\limits_{k:\, u_k \in C_i} u_k,
</math>
где <math>|C_i|</math> -- количество элементов в <math>i</math>-ом кластере.

Шаг 5. Переход на шаг 2.

Описание взято из <ref> Нейский И.М. Классификация и сравнение методов кластеризации.</ref>.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма Hard C-Means можно составить из множественных (всего их <math>nC</math>) вычислений квадратов нормы разности векторов <math>u_k</math> и кластерных центров <math>c_i</math>: <math>\|u_k-c_i\|^2</math>.

=== Макроструктура алгоритма ===
Как записано и в описании ядра алгоритма, основную часть метода составляют множественные (<math>Cn</math>) вычисления квадратов норм:

:<math>\|u_k-c_i\|^2</math>.

Также присутствуют данные вычислительные операции:

* Суммирование квадратов норм векторов:

:<math>
J = \sum\limits_{i=1}^C J_i = \sum\limits_{i=1}^C \left( \sum\limits_{k:\, u_k \in C_i} \|u_k -c_i \|^2 \right)
</math>

* Поэлементное суммирование векторов:

:<math>
c_i = \frac{1}{|C_i|} \sum\limits_{k:\, u_k \in C_i} u_k
</math>

=== Схема реализации последовательного алгоритма ===
Итерационный блок алгоритма можно описать на языке Python следующим образом:

<source lang="python3">
for i in range(n):
idx_min = 0
dist_min = ((u[i] - c[0]) ** 2).sum()

for j in range(1, C):
dist = ((u[i] - c[j]) ** 2).sum()
if dist < dist_min:
idx_min = j
dist_min = dist

M[i, idx_min] = 1
c_next[idx_min] += u[i]
c_next_cnt[idx_min] += 1
J += dist_min
</source>

=== Последовательная сложность алгоритма ===
Предполагаем, что предельная точность алгоритма достигаема менее, чем за <math>n</math> итераций. Иначе использование алгоритма можно считать нерациональным. Также предположим, что размерность <math>m</math> и количество кластерных центров <math>C</math> существенно меньше <math>n</math>.

Операция вычисления квадрата нормы разности векторов требует выполнения <math>m-1</math> арифметических операций сложения, <math>m</math> операций вычитания и <math>m</math> операций умножения.

Каждая итерация алгоритма требует выполнения:
* <math>nC</math> операций вычисления квадрата нормы разности векторов;
* <math>nC</math> операций сравнения квадрата нормы;
* <math>3n</math> операций сложения;

Таким образом, на каждой итерации имеем:
* <math>mnC</math> операций умножения;
* <math>(2mC + 3)n</math> арифметических операций сложения и вычитания;

В итоге имеем сложность последовательной реализации алгоритма <math>O(n)</math>.

=== Информационный граф ===
Граф алгоритма состоит из 4 видов вершин:

'''Первая''' группа вершин отмечена символом '''''M'''''. Ей соответствует вычисление минимального расстояния до кластерных центров, а также запись единицы в соответствующий столбец матрицы, обозначающей принадлежность кластерному центру:
* независимое вычисление расстояний от заданного элемента <math>u_i</math> до каждого из кластерных центров;
* последовательное сравнение полученных значений с целью отыскания максимума;
* операция записи 1 в соответствующий столбец матрицы принадлежности кластерным центрам;

'''Вторая''' вершина отмечена символом '''''J''''', на этом этапе происходит итоговый расчёт объектной функции.

'''Третья''' вершина помечена '''''if''''', на этом этапе происходит проверка условия достижения требуемой точности.

'''Четвертая''' соответствует операции пересчёта кластерных центров, она отмечена как '''''C'''''.

[[File:Cmeans.png|thumb|800px|center|Рисунок 1. Информационный граф алгоритма. Здесь '''''in''''' — ввод входных данных, '''''D''''' — вычисление минимального расстояния до кластерных центров и проставление принадлежности соответствующему кластерному центру, '''''J''''' — вычисление объектной функции по результатам полученных вычислений, '''''if''''' — проверка условия достижения желаемой точности, '''''C''''' — пересчёт кластерных центров и '''''out''''' — вывод полученных данных.]]

=== Ресурс параллелизма алгоритма ===
Основной ресурс параллелизма алгоритма составляет итерационный блок. Эта последовательность итераций может быть выполнена для каждого входного вектора <math>u_i</math> независимо. Однако, в конце выполнения каждого итерационного блока имеют место последовательные вычисления - сложение значений объектной функции, полученных независимо на каждом процессоре, а также перерасчет кластерных центров.

Высота [[глоссарий#Ярусно-параллельная форма графа алгоритма|ЯПФ]] оценивается как <math>O(1)</math> (при условии, что число итераций существенно меньше объёма выборки <math>n</math>). Ширина [[глоссарий#Ярусно-параллельная форма графа алгоритма|ЯПФ]] равна <math>n</math>.

Необходимо учитывать, что при небольшом объеме входной выборки, параллельная реализация алгоритма может лишь понизить производительность. В первую очередь это связано с пересылкой данных для вычисления итоговых значений объектной функции и кластерных центров.

=== Входные и выходные данные алгоритма ===
'''Входные данные:''' матрица <math>U\in \mathbb{R}^{n\times m}</math>, представляющая собой набор векторов <math>\{u_i\}_{i=1}^{n}, u_i \in \mathbb{R}^m</math>; количество кластеров <math>C \in \mathbb{N}</math>.

'''Объём входных данных:''' <math>nm+1</math>.

'''Выходные данные:''' набор векторов - кластерных центров <math>\{c_i\}_{i=1}^{C}, c_i \in \mathbb{R}^m</math>; матрица <math>M\in \mathbb{N}^{n\times C}</math> c информацией о разбиении объектов на кластера. Элемент <math>m_{ij}=1</math>, если <math>u_j \in C_i</math>, где <math>C_i</math> содержит все объекты <math>u</math>, принадлежащие кластеру <math>i</math. Остальные элементы <math>m_{ij}=0</math>.

'''Объём выходных данных:''' <math>C(n+m)</math>.

=== Свойства алгоритма ===
Достоинства:

* лёгкость реализации;
* вычислительная простота;
* может служить для кластеризации больших наборов числовых данных;

Недостатки:

* задание количества кластеров;
* отсутствие гарантии в нахождении оптимального решения;

Соотношение последовательной и параллельной сложности алгоритма: ???

Вычислительная мощность алгоритма, как отношение числа операций к суммарному объему входных и выходных данных равна константе.

Алгоритм является недетерменированным, т.к. он является итерационным с выходом по точности, а также использует датчик случайных чисел для инициализации кластерных центров.

Степень исхода вершины информационного графа ???

"Длинные" дуги в информационном графе ???

== Программная реализация алгоритма ==
=== Масштабируемость алгоритма и его реализации ===

==== Масштабируемость алгоритма ====
==== Масштабируемость реализации алгоритма ====

=== Существующие реализации алгоритма ===
* [http://projects.jasmeet.me/2013/03/HardCMeans.html Последовательная реализация алгоритма на MatLab]
* [https://github.com/artpar/Hard-Clustering-implementation Последовательная реализация алгоритма на С++]

== Литература ==
<references />

Участник:Каледа Александр/Строгий алгоритм С средних (Hard C-Means)

2016-10-15T18:27:12Z

Каледа Александр: /* Математическое описание алгоритма */

{{algorithm
| name = Строгий алгоритм С средних (Hard C-Means)
| serial_complexity = <math>O(n)</math>
| pf_height = <math>O(1)</math>
| pf_width = <math>O(n)</math>
| input_data = <math>nm+1</math>
| output_data = <math>(n+m)C</math>
}}

Авторы описания: [[Участник:Каледа_Александр|Каледа Александр]], [[Участник:Шапулин_Андрей|Шапулин Андрей]].

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===
'''Строгий алгоритм C средних''' ('''''Hard C-Means, HCM'''''; ''Jang, Sun and Mizutani, 1997'') один из наиболее широко используемых алгоритмов кластеризации данных<ref>Jan Jantzen «Neurofuzzy Modelling». Электронное издание.</ref>. Алгоритм разбивает большие наборы векторов в многомерном пространстве по заранее заданному количеству кластеров (т.е. является управляемым).

На вход алгоритму подается набор векторов и количество кластеров. Дополнительно может задаваться пороговая величина объектной функции, при достижении которой алгоритм останавливается. После окончания работы алгоритма каждый вектор будет отнесет к определенному кластерному центру. Алгоритм, являясь итерационным, зависит от начальных значений кластерных центров, а следовательно может не сходиться к локальному минимуму.

На первом шаге алгоритма происходит инициализация кластерным центров, это можно сделать выбрав случайным образом вектора из входного набора. На следующем шаге начинается итерационный процесс, завершающийся при достижении порогового значения объектной функцией или при минимальном отличии, от значения на предыдущей итерации.

Вычисления, выполняющиеся на очередной итерации алгоритма:

# Расчёт рядовой матрицы (сопоставление вектора соответствующему кластерному центру).
# Расчёт объектной функции.
# Пересчёт кластерных центров.

=== Математическое описание алгоритма ===
Исходные данные: матрица <math>U\in \mathbb{R}^{n\times m}</math>, представляющая собой набор векторов <math>\{u_i\}_{i=1}^{n}, u_i \in \mathbb{R}^m</math>; количество кластеров <math>C \in \mathbb{N}</math>.

Вычисляемые данные: набор векторов - кластерных центров <math>\{c_i\}_{i=1}^{C}, c_i \in \mathbb{R}^m</math>; матрица <math>M\in \mathbb{N}^{n\times C}</math> c информацией о разбиении объектов на кластера. Элемент <math>m_{ij}=1</math>, если <math>u_j \in C_i</math>, где <math>C_i</math> содержит все объекты <math>u</math>, принадлежащие кластеру <math>i</math>. Остальные элементы <math>m_{ij}=0</math>.

Алгоритм:

Шаг 1. Инициализация кластерных центров <math>c_i, i = 1, 2, \dots, C.</math> Это можно сделать выбрав случайным образом C векторов из входного набора <math>\{u_i\}_{i=1}^{n}</math>

Шаг 2. Вычисление рядовой матрицы M.

Матрица <math>M</math> состоит из элементов <math>M = \|m_{ik}\|</math>.

:<math>
m_{ik} = \begin{cases}
1, & \|u_k-c_i\|^2 \leqslant \|u_k-c_j\|^2 \;\; \text{for all } i \neq j; \;\; (i,j=1,2,\ldots,C; \; k = 1,2,\ldots,n)\\
0, & \text{otherwise}.
\end{cases}
</math>

Шаг 3. Расчет объектной функции:

:<math>
J = \sum\limits_{i=1}^C J_i = \sum\limits_{i=1}^C \left( \sum\limits_{k:\, u_k \in C_i} \|u_k -c_i \|^2 \right)</math>.

На этом шаге происходит остановка и выход из цикла, если полученное значение ниже пороговой величины или полученное значение не сильно отличается от значений, полученных на предыдущих циклах.

Шаг 4. Пересчет кластерных центров.

Пересчет кластерных центров выполняется в соответствии со следующим уравнением:
:<math>
c_i = \frac{1}{|C_i|} \sum\limits_{k:\, u_k \in C_i} u_k,
</math>
где <math>|C_i|</math> -- количество элементов в <math>i</math>-ом кластере.

Шаг 5. Переход на шаг 2.

Описание взято из <ref> Нейский И.М. Классификация и сравнение методов кластеризации.</ref>.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма Hard C-Means можно составить из множественных (всего их <math>nC</math>) вычислений квадратов нормы разности векторов <math>u_k</math> и кластерных центров <math>c_i</math>: <math>\|u_k-c_i\|^2</math>.

=== Макроструктура алгоритма ===
Как записано и в описании ядра алгоритма, основную часть метода составляют множественные (<math>Cn</math>) вычисления квадратов норм:

:<math>\|u_k-c_i\|^2</math>.

Также присутствуют данные вычислительные операции:

* Суммирование квадратов норм векторов:

:<math>
J = \sum\limits_{i=1}^C J_i = \sum\limits_{i=1}^C \left( \sum\limits_{k:\, u_k \in C_i} \|u_k -c_i \|^2 \right)
</math>

* Поэлементное суммирование векторов:

:<math>
c_i = \frac{1}{|C_i|} \sum\limits_{k:\, u_k \in C_i} u_k
</math>

=== Схема реализации последовательного алгоритма ===
Итерационный блок алгоритма можно описать на языке Python следующим образом:

<source lang="python3">
for i in range(n):
idx_min = 0
dist_min = ((u[i] - c[0]) ** 2).sum()

for j in range(1, C):
dist = ((u[i] - c[j]) ** 2).sum()
if dist < dist_min:
idx_min = j
dist_min = dist

M[i, idx_min] = 1
c_next[idx_min] += u[i]
c_next_cnt[idx_min] += 1
J += dist_min
</source>

=== Последовательная сложность алгоритма ===
Предполагаем, что предельная точность алгоритма достигаема менее, чем за <math>n</math> итераций. Иначе использование алгоритма можно считать нерациональным. Также предположим, что размерность <math>m</math> и количество кластерных центров <math>C</math> существенно меньше <math>n</math>.

Операция вычисления квадрата нормы разности векторов требует выполнения <math>m-1</math> арифметических операций сложения, <math>m</math> операций вычитания и <math>m</math> операций умножения.

Каждая итерация алгоритма требует выполнения:
* <math>nC</math> операций вычисления квадрата нормы разности векторов;
* <math>nC</math> операций сравнения квадрата нормы;
* <math>3n</math> операций сложения;

Таким образом, на каждой итерации имеем:
* <math>mnC</math> операций умножения;
* <math>(2mC + 3)n</math> арифметических операций сложения и вычитания;

В итоге имеем сложность последовательной реализации алгоритма <math>O(n)</math>.

=== Информационный граф ===
Граф алгоритма состоит из 4 видов вершин:

'''Первая''' группа вершин отмечена символом '''''M'''''. Ей соответствует вычисление минимального расстояния до кластерных центров, а также запись единицы в соответствующий столбец матрицы, обозначающей принадлежность кластерному центру:
* независимое вычисление расстояний от заданного элемента <math>u_i</math> до каждого из кластерных центров;
* последовательное сравнение полученных значений с целью отыскания максимума;
* операция записи 1 в соответствующий столбец матрицы принадлежности кластерным центрам;

'''Вторая''' вершина отмечена символом '''''J''''', на этом этапе происходит итоговый расчёт объектной функции.

'''Третья''' вершина помечена '''''if''''', на этом этапе происходит проверка условия достижения требуемой точности.

'''Четвертая''' соответствует операции пересчёта кластерных центров, она отмечена как '''''C'''''.

[[File:Cmeans.png|thumb|800px|center|Рисунок 1. Информационный граф алгоритма. Здесь '''''in''''' — ввод входных данных, '''''D''''' — вычисление минимального расстояния до кластерных центров и проставление принадлежности соответствующему кластерному центру, '''''J''''' — вычисление объектной функции по результатам полученных вычислений, '''''if''''' — проверка условия достижения желаемой точности, '''''C''''' — пересчёт кластерных центров и '''''out''''' — вывод полученных данных.]]

=== Ресурс параллелизма алгоритма ===
Основной ресурс параллелизма алгоритма составляет итерационный блок. Эта последовательность итераций может быть выполнена для каждого входного вектора <math>u_i</math> независимо. Однако, в конце выполнения каждого итерационного блока имеют место последовательные вычисления - сложение значений объектной функции, полученных независимо на каждом процессоре, а также перерасчет кластерных центров.

Высота [[глоссарий#Ярусно-параллельная форма графа алгоритма|ЯПФ]] оценивается как <math>O(1)</math> (при условии, что число итераций существенно меньше объёма выборки <math>n</math>). Ширина [[глоссарий#Ярусно-параллельная форма графа алгоритма|ЯПФ]] равна <math>n</math>.

Необходимо учитывать, что при небольшом объеме входной выборки, параллельная реализация алгоритма может лишь понизить производительность. В первую очередь это связано с пересылкой данных для вычисления итоговых значений объектной функции и кластерных центров.

=== Входные и выходные данные алгоритма ===
'''Входные данные:''' матрица <math>U\in \mathbb{R}^{n\times m}</math>, представляющая собой набор векторов <math>\{u_i\}_{i=1}^{n}, u_i \in \mathbb{R}^m</math>; количество кластеров <math>C \in \mathbb{N}</math>.

'''Объём входных данных:''' <math>nm+1</math>.

'''Выходные данные:''' набор векторов - кластерных центров <math>\{c_i\}_{i=1}^{C}, c_i \in \mathbb{R}^m</math>; вектор <math>y \in \mathbb{N}^m</math>, содержащий номер найденного кластера для каждого объекта <math>u_i</math>.

'''Объём выходных данных:''' <math>mC + n</math>.

=== Свойства алгоритма ===
Достоинства:

* лёгкость реализации;
* вычислительная простота;
* может служить для кластеризации больших наборов числовых данных;

Недостатки:

* задание количества кластеров;
* отсутствие гарантии в нахождении оптимального решения;

Соотношение последовательной и параллельной сложности алгоритма: ???

Вычислительная мощность алгоритма, как отношение числа операций к суммарному объему входных и выходных данных равна константе.

Алгоритм является недетерменированным, т.к. он является итерационным с выходом по точности, а также использует датчик случайных чисел для инициализации кластерных центров.

Степень исхода вершины информационного графа ???

"Длинные" дуги в информационном графе ???

== Программная реализация алгоритма ==
=== Масштабируемость алгоритма и его реализации ===

==== Масштабируемость алгоритма ====
==== Масштабируемость реализации алгоритма ====

=== Существующие реализации алгоритма ===
* [http://projects.jasmeet.me/2013/03/HardCMeans.html Последовательная реализация алгоритма на MatLab]
* [https://github.com/artpar/Hard-Clustering-implementation Последовательная реализация алгоритма на С++]

== Литература ==
<references />

Участник:Каледа Александр/Строгий алгоритм С средних (Hard C-Means)

2016-10-15T18:26:02Z

Каледа Александр: /* Математическое описание алгоритма */

{{algorithm
| name = Строгий алгоритм С средних (Hard C-Means)
| serial_complexity = <math>O(n)</math>
| pf_height = <math>O(1)</math>
| pf_width = <math>O(n)</math>
| input_data = <math>nm+1</math>
| output_data = <math>(n+m)C</math>
}}

Авторы описания: [[Участник:Каледа_Александр|Каледа Александр]], [[Участник:Шапулин_Андрей|Шапулин Андрей]].

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===
'''Строгий алгоритм C средних''' ('''''Hard C-Means, HCM'''''; ''Jang, Sun and Mizutani, 1997'') один из наиболее широко используемых алгоритмов кластеризации данных<ref>Jan Jantzen «Neurofuzzy Modelling». Электронное издание.</ref>. Алгоритм разбивает большие наборы векторов в многомерном пространстве по заранее заданному количеству кластеров (т.е. является управляемым).

На вход алгоритму подается набор векторов и количество кластеров. Дополнительно может задаваться пороговая величина объектной функции, при достижении которой алгоритм останавливается. После окончания работы алгоритма каждый вектор будет отнесет к определенному кластерному центру. Алгоритм, являясь итерационным, зависит от начальных значений кластерных центров, а следовательно может не сходиться к локальному минимуму.

На первом шаге алгоритма происходит инициализация кластерным центров, это можно сделать выбрав случайным образом вектора из входного набора. На следующем шаге начинается итерационный процесс, завершающийся при достижении порогового значения объектной функцией или при минимальном отличии, от значения на предыдущей итерации.

Вычисления, выполняющиеся на очередной итерации алгоритма:

# Расчёт рядовой матрицы (сопоставление вектора соответствующему кластерному центру).
# Расчёт объектной функции.
# Пересчёт кластерных центров.

=== Математическое описание алгоритма ===
Исходные данные: матрица <math>U\in \mathbb{R}^{n\times m}</math>, представляющая собой набор векторов <math>\{u_i\}_{i=1}^{n}, u_i \in \mathbb{R}^m</math>; количество кластеров <math>C \in \mathbb{N}</math>.

Вычисляемые данные: набор векторов - кластерных центров <math>\{c_i\}_{i=1}^{C}, c_i \in \mathbb{R}^m</math>; матрица <math>M\in \mathbb{N}^{n\times C}</math> c информацией о разбиении объектов на кластера. Элемент <math>m_{ij}=1</math>, если <math>u_j \in C_i</math>, где <math>C_i</math> содержит все объекты <math>u</math>, принадлежащие кластеру <math>i</math. Остальные элементы <math>m_{ij}=0</math>.

Алгоритм:

Шаг 1. Инициализация кластерных центров <math>c_i, i = 1, 2, \dots, C.</math> Это можно сделать выбрав случайным образом C векторов из входного набора <math>\{u_i\}_{i=1}^{n}</math>

Шаг 2. Вычисление рядовой матрицы M.

Матрица <math>M</math> состоит из элементов <math>M = \|m_{ik}\|</math>.

:<math>
m_{ik} = \begin{cases}
1, & \|u_k-c_i\|^2 \leqslant \|u_k-c_j\|^2 \;\; \text{for all } i \neq j; \;\; (i,j=1,2,\ldots,C; \; k = 1,2,\ldots,n)\\
0, & \text{otherwise}.
\end{cases}
</math>

Шаг 3. Расчет объектной функции:

:<math>
J = \sum\limits_{i=1}^C J_i = \sum\limits_{i=1}^C \left( \sum\limits_{k:\, u_k \in C_i} \|u_k -c_i \|^2 \right)</math>.

На этом шаге происходит остановка и выход из цикла, если полученное значение ниже пороговой величины или полученное значение не сильно отличается от значений, полученных на предыдущих циклах.

Шаг 4. Пересчет кластерных центров.

Пересчет кластерных центров выполняется в соответствии со следующим уравнением:
:<math>
c_i = \frac{1}{|C_i|} \sum\limits_{k:\, u_k \in C_i} u_k,
</math>
где <math>|C_i|</math> -- количество элементов в <math>i</math>-ом кластере.

Шаг 5. Переход на шаг 2.

Описание взято из <ref> Нейский И.М. Классификация и сравнение методов кластеризации.</ref>.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма Hard C-Means можно составить из множественных (всего их <math>nC</math>) вычислений квадратов нормы разности векторов <math>u_k</math> и кластерных центров <math>c_i</math>: <math>\|u_k-c_i\|^2</math>.

=== Макроструктура алгоритма ===
Как записано и в описании ядра алгоритма, основную часть метода составляют множественные (<math>Cn</math>) вычисления квадратов норм:

:<math>\|u_k-c_i\|^2</math>.

Также присутствуют данные вычислительные операции:

* Суммирование квадратов норм векторов:

:<math>
J = \sum\limits_{i=1}^C J_i = \sum\limits_{i=1}^C \left( \sum\limits_{k:\, u_k \in C_i} \|u_k -c_i \|^2 \right)
</math>

* Поэлементное суммирование векторов:

:<math>
c_i = \frac{1}{|C_i|} \sum\limits_{k:\, u_k \in C_i} u_k
</math>

=== Схема реализации последовательного алгоритма ===
Итерационный блок алгоритма можно описать на языке Python следующим образом:

<source lang="python3">
for i in range(n):
idx_min = 0
dist_min = ((u[i] - c[0]) ** 2).sum()

for j in range(1, C):
dist = ((u[i] - c[j]) ** 2).sum()
if dist < dist_min:
idx_min = j
dist_min = dist

M[i, idx_min] = 1
c_next[idx_min] += u[i]
c_next_cnt[idx_min] += 1
J += dist_min
</source>

=== Последовательная сложность алгоритма ===
Предполагаем, что предельная точность алгоритма достигаема менее, чем за <math>n</math> итераций. Иначе использование алгоритма можно считать нерациональным. Также предположим, что размерность <math>m</math> и количество кластерных центров <math>C</math> существенно меньше <math>n</math>.

Операция вычисления квадрата нормы разности векторов требует выполнения <math>m-1</math> арифметических операций сложения, <math>m</math> операций вычитания и <math>m</math> операций умножения.

Каждая итерация алгоритма требует выполнения:
* <math>nC</math> операций вычисления квадрата нормы разности векторов;
* <math>nC</math> операций сравнения квадрата нормы;
* <math>3n</math> операций сложения;

Таким образом, на каждой итерации имеем:
* <math>mnC</math> операций умножения;
* <math>(2mC + 3)n</math> арифметических операций сложения и вычитания;

В итоге имеем сложность последовательной реализации алгоритма <math>O(n)</math>.

=== Информационный граф ===
Граф алгоритма состоит из 4 видов вершин:

'''Первая''' группа вершин отмечена символом '''''M'''''. Ей соответствует вычисление минимального расстояния до кластерных центров, а также запись единицы в соответствующий столбец матрицы, обозначающей принадлежность кластерному центру:
* независимое вычисление расстояний от заданного элемента <math>u_i</math> до каждого из кластерных центров;
* последовательное сравнение полученных значений с целью отыскания максимума;
* операция записи 1 в соответствующий столбец матрицы принадлежности кластерным центрам;

'''Вторая''' вершина отмечена символом '''''J''''', на этом этапе происходит итоговый расчёт объектной функции.

'''Третья''' вершина помечена '''''if''''', на этом этапе происходит проверка условия достижения требуемой точности.

'''Четвертая''' соответствует операции пересчёта кластерных центров, она отмечена как '''''C'''''.

[[File:Cmeans.png|thumb|800px|center|Рисунок 1. Информационный граф алгоритма. Здесь '''''in''''' — ввод входных данных, '''''D''''' — вычисление минимального расстояния до кластерных центров и проставление принадлежности соответствующему кластерному центру, '''''J''''' — вычисление объектной функции по результатам полученных вычислений, '''''if''''' — проверка условия достижения желаемой точности, '''''C''''' — пересчёт кластерных центров и '''''out''''' — вывод полученных данных.]]

=== Ресурс параллелизма алгоритма ===
Основной ресурс параллелизма алгоритма составляет итерационный блок. Эта последовательность итераций может быть выполнена для каждого входного вектора <math>u_i</math> независимо. Однако, в конце выполнения каждого итерационного блока имеют место последовательные вычисления - сложение значений объектной функции, полученных независимо на каждом процессоре, а также перерасчет кластерных центров.

Высота [[глоссарий#Ярусно-параллельная форма графа алгоритма|ЯПФ]] оценивается как <math>O(1)</math> (при условии, что число итераций существенно меньше объёма выборки <math>n</math>). Ширина [[глоссарий#Ярусно-параллельная форма графа алгоритма|ЯПФ]] равна <math>n</math>.

Необходимо учитывать, что при небольшом объеме входной выборки, параллельная реализация алгоритма может лишь понизить производительность. В первую очередь это связано с пересылкой данных для вычисления итоговых значений объектной функции и кластерных центров.

=== Входные и выходные данные алгоритма ===
'''Входные данные:''' матрица <math>U\in \mathbb{R}^{n\times m}</math>, представляющая собой набор векторов <math>\{u_i\}_{i=1}^{n}, u_i \in \mathbb{R}^m</math>; количество кластеров <math>C \in \mathbb{N}</math>.

'''Объём входных данных:''' <math>nm+1</math>.

'''Выходные данные:''' набор векторов - кластерных центров <math>\{c_i\}_{i=1}^{C}, c_i \in \mathbb{R}^m</math>; вектор <math>y \in \mathbb{N}^m</math>, содержащий номер найденного кластера для каждого объекта <math>u_i</math>.

'''Объём выходных данных:''' <math>mC + n</math>.

=== Свойства алгоритма ===
Достоинства:

* лёгкость реализации;
* вычислительная простота;
* может служить для кластеризации больших наборов числовых данных;

Недостатки:

* задание количества кластеров;
* отсутствие гарантии в нахождении оптимального решения;

Соотношение последовательной и параллельной сложности алгоритма: ???

Вычислительная мощность алгоритма, как отношение числа операций к суммарному объему входных и выходных данных равна константе.

Алгоритм является недетерменированным, т.к. он является итерационным с выходом по точности, а также использует датчик случайных чисел для инициализации кластерных центров.

Степень исхода вершины информационного графа ???

"Длинные" дуги в информационном графе ???

== Программная реализация алгоритма ==
=== Масштабируемость алгоритма и его реализации ===

==== Масштабируемость алгоритма ====
==== Масштабируемость реализации алгоритма ====

=== Существующие реализации алгоритма ===
* [http://projects.jasmeet.me/2013/03/HardCMeans.html Последовательная реализация алгоритма на MatLab]
* [https://github.com/artpar/Hard-Clustering-implementation Последовательная реализация алгоритма на С++]

== Литература ==
<references />

Файл:Cmeans.png

2016-10-15T17:49:57Z

Каледа Александр: Каледа Александр загрузил новую версию Файл:Cmeans.png

Файл:Cmeans.png

2016-10-15T17:46:34Z

Каледа Александр:

Участник:Каледа Александр/Строгий алгоритм С средних (Hard C-Means)

2016-10-15T13:41:11Z

Каледа Александр: /* Информационный граф */

{{algorithm
| name = Строгий алгоритм С средних (Hard C-Means)
| serial_complexity = <math>O(n)</math>
| pf_height = <math>O(1)</math>
| pf_width = <math>O(n)</math>
| input_data = <math>nm+1</math>
| output_data = <math>(n+m)C</math>
}}

Авторы описания: [[Участник:Каледа_Александр|Каледа Александр]], [[Участник:Шапулин_Андрей|Шапулин Андрей]].

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===
'''Строгий алгоритм C средних''' ('''''Hard C-Means, HCM'''''; ''Jang, Sun and Mizutani, 1997'') один из наиболее широко используемых алгоритмов кластеризации данных<ref>Jan Jantzen «Neurofuzzy Modelling». Электронное издание.</ref>. Алгоритм разбивает большие наборы векторов в многомерном пространстве по заранее заданному количеству кластеров (т.е. является управляемым).

На вход алгоритму подается набор векторов и количество кластеров. Дополнительно может задаваться пороговая величина объектной функции, при достижении которой алгоритм останавливается. После окончания работы алгоритма каждый вектор будет отнесет к определенному кластерному центру. Алгоритм, являясь итерационным, зависит от начальных значений кластерных центров, а следовательно может не сходиться к локальному минимуму.

На первом шаге алгоритма происходит инициализация кластерным центров, это можно сделать выбрав случайным образом вектора из входного набора. На следующем шаге начинается итерационный процесс, завершающийся при достижении порогового значения объектной функцией или при минимальном отличии, от значения на предыдущей итерации.

Вычисления, выполняющиеся на очередной итерации алгоритма:

# Расчёт рядовой матрицы (сопоставление вектора соответствующему кластерному центру).
# Расчёт объектной функции.
# Пересчёт кластерных центров.

=== Математическое описание алгоритма ===
Исходные данные: матрица <math>U\in \mathbb{R}^{n\times m}</math>, представляющая собой набор векторов <math>\{u_i\}_{i=1}^{n}, u_i \in \mathbb{R}^m</math>; количество кластеров <math>C \in \mathbb{N}</math>.

Вычисляемые данные: набор векторов - кластерных центров <math>\{c_i\}_{i=1}^{C}, c_i \in \mathbb{R}^m</math>; вектор <math>y \in \mathbb{N}^m</math>, содержащий номер найденного кластера для каждого объекта <math>u_i</math>.

Алгоритм:

Шаг 1. Инициализация кластерных центров <math>c_i, i = 1, 2, \dots, C.</math> Это можно сделать выбрав случайным образом C векторов из входного набора <math>\{u_i\}_{i=1}^{n}</math>

Шаг 2. Вычисление рядовой матрицы M.

Матрица <math>M</math> состоит из элементов <math>M = \|m_{ik}\|</math>.

:<math>
m_{ik} = \begin{cases}
1, & \|u_k-c_i\|^2 \leqslant \|u_k-c_j\|^2 \;\; \text{for all } i \neq j; \;\; (i,j=1,2,\ldots,C; \; k = 1,2,\ldots,n)\\
0, & \text{otherwise}.
\end{cases}
</math>

Шаг 3. Расчет объектной функции:

:<math>
J = \sum\limits_{i=1}^C J_i = \sum\limits_{i=1}^C \left( \sum\limits_{k:\, u_k \in C_i} \|u_k -c_i \|^2 \right)</math>, где <math>C_i = \{u_k\}, m_{ik} = 1</math>. То есть <math>C_i</math> содержит все объекты, принадлежащие кластеру <math>i</math>.

На этом шаге происходит остановка и выход из цикла, если полученное значение ниже пороговой величины или полученное значение не сильно отличается от значений, полученных на предыдущих циклах.

Шаг 4. Пересчет кластерных центров.

Пересчет кластерных центров выполняется в соответствии со следующим уравнением:
:<math>
c_i = \frac{1}{|C_i|} \sum\limits_{k:\, u_k \in C_i} u_k,
</math>
где <math>|C_i|</math> -- количество элементов в <math>i</math>-ом кластере.

Шаг 5. Переход на шаг 2.

Описание взято из <ref> Нейский И.М. Классификация и сравнение методов кластеризации.</ref>.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма Hard C-Means можно составить из множественных (всего их <math>nC</math>) вычислений квадратов нормы разности векторов <math>u_k</math> и кластерных центров <math>c_i</math>: <math>\|u_k-c_i\|^2</math>.

=== Макроструктура алгоритма ===
Как записано и в описании ядра алгоритма, основную часть метода составляют множественные (<math>Cn</math>) вычисления квадратов норм:

:<math>\|u_k-c_i\|^2</math>.

Также присутствуют данные вычислительные операции:

* Суммирование квадратов норм векторов:

:<math>
J = \sum\limits_{i=1}^C J_i = \sum\limits_{i=1}^C \left( \sum\limits_{k:\, u_k \in C_i} \|u_k -c_i \|^2 \right)
</math>

* Поэлементное суммирование векторов:

:<math>
c_i = \frac{1}{|C_i|} \sum\limits_{k:\, u_k \in C_i} u_k
</math>

=== Схема реализации последовательного алгоритма ===
Итерационный блок алгоритма можно описать на языке Python следующим образом:

<source lang="python3">
for i in range(n):
idx_min = 0
dist_min = ((u[i] - c[0]) ** 2).sum()

for j in range(1, C):
dist = ((u[i] - c[j]) ** 2).sum()
if dist < dist_min:
idx_min = j
dist_min = dist

M[i, idx_min] = 1
c_next[idx_min] += u[i]
c_next_cnt[idx_min] += 1
J += dist_min
</source>

=== Последовательная сложность алгоритма ===
Предполагаем, что предельная точность алгоритма достигаема менее, чем за <math>n</math> итераций. Иначе использование алгоритма можно считать нерациональным. Также предположим, что размерность <math>m</math> и количество кластерных центров <math>C</math> существенно меньше <math>n</math>.

Операция вычисления квадрата нормы разности векторов требует выполнения <math>m-1</math> арифметических операций сложения, <math>m</math> операций вычитания и <math>m</math> операций умножения.

Каждая итерация алгоритма требует выполнения:
* <math>nC</math> операций вычисления квадрата нормы разности векторов;
* <math>nC</math> операций сравнения квадрата нормы;
* <math>3n</math> операций сложения;

Таким образом, на каждой итерации имеем:
* <math>mnC</math> операций умножения;
* <math>(2mC + 3)n</math> арифметических операций сложения и вычитания;

В итоге имеем сложность последовательной реализации алгоритма <math>O(n)</math>.

=== Информационный граф ===
Граф алгоритма состоит из 4 видов вершин:

'''Первая''' группа вершин отмечена символом '''''M'''''. Ей соответствует вычисление минимального расстояния до кластерных центров, а также запись единицы в соответствующий столбец матрицы, обозначающей принадлежность кластерному центру:
* независимое вычисление расстояний от заданного элемента <math>u_i</math> до каждого из кластерных центров;
* последовательное сравнение полученных значений с целью отыскания максимума;
* операция записи 1 в соответствующий столбец матрицы принадлежности кластерным центрам;

'''Вторая''' вершина отмечена символом '''''J''''', на этом этапе происходит итоговый расчёт объектной функции.

'''Третья''' вершина помечена '''''if''''', на этом этапе происходит проверка условия достижения требуемой точности.

'''Четвертая''' соответствует операции пересчёта кластерных центров, она отмечена как '''''C'''''.

[[File:Cmeans.png|thumb|800px|center|Рисунок 1. Информационный граф алгоритма. Здесь '''''in''''' — ввод входных данных, '''''D''''' — вычисление минимального расстояния до кластерных центров и проставление принадлежности соответствующему кластерному центру, '''''J''''' — вычисление объектной функции по результатам полученных вычислений, '''''if''''' — проверка условия достижения желаемой точности, '''''C''''' — пересчёт кластерных центров и '''''out''''' — вывод полученных данных.]]

=== Ресурс параллелизма алгоритма ===
Основной ресурс параллелизма алгоритма составляет итерационный блок. Эта последовательность итераций может быть выполнена для каждого входного вектора <math>u_i</math> независимо. Однако, в конце выполнения каждого итерационного блока имеют место последовательные вычисления - сложение значений объектной функции, полученных независимо на каждом процессоре, а также перерасчет кластерных центров.

Высота [[глоссарий#Ярусно-параллельная форма графа алгоритма|ЯПФ]] оценивается как <math>O(1)</math> (при условии, что число итераций существенно меньше объёма выборки <math>n</math>). Ширина [[глоссарий#Ярусно-параллельная форма графа алгоритма|ЯПФ]] равна <math>n</math>.

Необходимо учитывать, что при небольшом объеме входной выборки, параллельная реализация алгоритма может лишь понизить производительность. В первую очередь это связано с пересылкой данных для вычисления итоговых значений объектной функции и кластерных центров.

=== Входные и выходные данные алгоритма ===
'''Входные данные:''' матрица <math>U\in \mathbb{R}^{n\times m}</math>, представляющая собой набор векторов <math>\{u_i\}_{i=1}^{n}, u_i \in \mathbb{R}^m</math>; количество кластеров <math>C \in \mathbb{N}</math>.

'''Объём входных данных:''' <math>nm+1</math>.

'''Выходные данные:''' набор векторов - кластерных центров <math>\{c_i\}_{i=1}^{C}, c_i \in \mathbb{R}^m</math>; вектор <math>y \in \mathbb{N}^m</math>, содержащий номер найденного кластера для каждого объекта <math>u_i</math>.

'''Объём выходных данных:''' <math>mC + n</math>.

=== Свойства алгоритма ===
Достоинства:

* лёгкость реализации;
* вычислительная простота;
* может служить для кластеризации больших наборов числовых данных;

Недостатки:

* задание количества кластеров;
* отсутствие гарантии в нахождении оптимального решения;

Соотношение последовательной и параллельной сложности алгоритма: ???

Вычислительная мощность алгоритма, как отношение числа операций к суммарному объему входных и выходных данных равна константе.

Алгоритм является недетерменированным, т.к. он является итерационным с выходом по точности, а также использует датчик случайных чисел для инициализации кластерных центров.

Степень исхода вершины информационного графа ???

"Длинные" дуги в информационном графе ???

== Программная реализация алгоритма ==
=== Масштабируемость алгоритма и его реализации ===

==== Масштабируемость алгоритма ====
==== Масштабируемость реализации алгоритма ====

=== Существующие реализации алгоритма ===
* [http://projects.jasmeet.me/2013/03/HardCMeans.html Последовательная реализация алгоритма на MatLab]
* [https://github.com/artpar/Hard-Clustering-implementation Последовательная реализация алгоритма на С++]

== Литература ==
<references />

Участник:Шапулин Андрей

2016-10-15T12:38:04Z

Каледа Александр: Новая страница: «Шапулин Андрей Валентинович — студент 617 группы (2016/2017) факультета ВМК МГУ им. М.В.Ломонос…»

Шапулин Андрей Валентинович — студент 617 группы (2016/2017) факультета ВМК МГУ им. М.В.Ломоносова.

Участник:Каледа Александр

2016-10-15T12:36:27Z

Каледа Александр: Новая страница: «Каледа Александр Васильевич — студент 619 группы (2016/2017) факультета ВМК МГУ им. М.В.Ломонос…»

Каледа Александр Васильевич — студент 619 группы (2016/2017) факультета ВМК МГУ им. М.В.Ломоносова.

Участник:Каледа Александр/Строгий алгоритм С средних (Hard C-Means)

2016-10-15T12:35:01Z

Каледа Александр:

Участник:Каледа Александр/Строгий алгоритм С средних (Hard C-Means)

2016-10-15T11:39:42Z

Каледа Александр: /* Свойства алгоритма */

Участник:Каледа Александр/Строгий алгоритм С средних (Hard C-Means)

2016-10-15T11:39:05Z

Каледа Александр:

Участник:Каледа Александр/Строгий алгоритм С средних (Hard C-Means)

2016-10-15T11:37:43Z

Каледа Александр: /* Программная реализация алгоритма */

Участник:Каледа Александр/Строгий алгоритм С средних (Hard C-Means)

2016-10-15T11:36:40Z

Каледа Александр: /* Свойства алгоритма */

Участник:Каледа Александр/Строгий алгоритм С средних (Hard C-Means)

2016-10-15T11:35:32Z

Каледа Александр: /* Входные и выходные данные алгоритма */