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

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

2016-12-18T14:02:00Z

Marina abramenkova:

{{Assignment|{{REVISIONUSER}}}}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

<source lang="C++">

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

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

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

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

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

}
return u;
}
</source>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

<references \>

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

2016-12-18T14:00:38Z

Marina abramenkova: /* Статья Участник:Demon_smd/Нечеткий_алгоритм_С_средних */

= Статья [[Участник:Demon_smd/Нечеткий_алгоритм_С_средних]] =

* 1.8 — Из текста непонятно, откуда получен логарифм. [[Участник:Chalker|Chalker]] ([[Обсуждение участника:Chalker|обсуждение]]) 23:11, 17 декабря 2016 (MSK)
* 1.8 — «взятие адреса» — имеется ввиду чтение элемента из памяти, да? [[Участник:Chalker|Chalker]] ([[Обсуждение участника:Chalker|обсуждение]]) 23:11, 17 декабря 2016 (MSK)
** Да, верно
*** Поправьте текст, пожалуйста. У «взятия адреса» есть определение и оно не соответствует тому, как вы это использовали. [[Участник:Chalker|Chalker]] ([[Обсуждение участника:Chalker|обсуждение]]) 16:50, 18 декабря 2016 (MSK)
* 1.6 — в оценки сложности итерации не учтена размерность входных векторов. [[Участник:Chalker|Chalker]] ([[Обсуждение участника:Chalker|обсуждение]]) 23:11, 17 декабря 2016 (MSK)
* 1.4 — не описано условие останова алгоритма. [[Участник:Chalker|Chalker]] ([[Обсуждение участника:Chalker|обсуждение]]) 23:11, 17 декабря 2016 (MSK)
** Условие останова описано в пункте 1.1 (четвертый подпункт)
* 1.2 — n и C не введены. [[Участник:Chalker|Chalker]] ([[Обсуждение участника:Chalker|обсуждение]]) 23:11, 17 декабря 2016 (MSK)
** Исправлено
* 1.2 — в одном предложении написано, что xᵢ — вектор, а через запятую — что это i-тый компонент N-мерного вектора x. Если элементы вектора — это вектора, то, возможно, стоило написать что это матрица? (А матрица ли это?). [[Участник:Chalker|Chalker]] ([[Обсуждение участника:Chalker|обсуждение]]) 23:11, 17 декабря 2016 (MSK)
** Опечатка(тут X в uppercase): xᵢ — вектор, но в тоже время это i-тый компонент N-мерного вектора X (в общем случае X - это вектор из N элементов, которые кластеризуются. С практической точки зрения элементы это тоже вектора)
* 1.2 — Jₘ определён, но больше нигде не используется.
** Без обозначения величина выглядит странно. И нужна она только для математического описания.
* Пунктуация местами отсутствует в принципе. В том числе и в самом первом предложении. [[Участник:Chalker|Chalker]] ([[Обсуждение участника:Chalker|обсуждение]]) 20:15, 17 декабря 2016 (MSK)
** В первом предложении поправили.
* Размерность входных векторов (p) не входит в сложность? Длина векторов (определена как |X| ниже) не входит в сложность? [[Участник:Chalker|Chalker]] ([[Обсуждение участника:Chalker|обсуждение]]) 20:15, 17 декабря 2016 (MSK)
** |X| входит (N - это тоже самое, исправили N на |X| для однообразия), во всех источниках длина кластеризуемых векторов (p) в сложности не фигурирует (в общем случае кластеризуются абстрактные объекты).
* Где определены N и D? Во входных данных их нет. [[Участник:Chalker|Chalker]] ([[Обсуждение участника:Chalker|обсуждение]]) 20:15, 17 декабря 2016 (MSK)
** исправили N на |X|
* 1.6 — в терминах каких операций вычисляется сложность? [[Участник:Chalker|Chalker]] ([[Обсуждение участника:Chalker|обсуждение]]) 20:15, 17 декабря 2016 (MSK)

----

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

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

2016-12-18T14:00:02Z

Marina abramenkova: /* Математическое описание алгоритма */

{{Assignment|{{REVISIONUSER}}}}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

<source lang="C++">

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

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

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

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

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

}
return u;
}
</source>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

<references \>

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

2016-12-18T13:46:54Z

Marina abramenkova:

{{Assignment|{{REVISIONUSER}}}}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

<source lang="C++">

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

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

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

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

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

}
return u;
}
</source>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

<references \>

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

2016-12-18T13:30:22Z

Marina abramenkova: /* Статья Участник:Demon_smd/Нечеткий_алгоритм_С_средних */

= Статья [[Участник:Demon_smd/Нечеткий_алгоритм_С_средних]] =

* 1.8 — Из текста непонятно, откуда получен логарифм. [[Участник:Chalker|Chalker]] ([[Обсуждение участника:Chalker|обсуждение]]) 23:11, 17 декабря 2016 (MSK)
* 1.8 — «взятие адреса» — имеется ввиду чтение элемента из памяти, да? [[Участник:Chalker|Chalker]] ([[Обсуждение участника:Chalker|обсуждение]]) 23:11, 17 декабря 2016 (MSK)
** Да, верно
* 1.6 — в оценки сложности итерации не учтена размерность входных векторов. [[Участник:Chalker|Chalker]] ([[Обсуждение участника:Chalker|обсуждение]]) 23:11, 17 декабря 2016 (MSK)
* 1.4 — не описано условие останова алгоритма. [[Участник:Chalker|Chalker]] ([[Обсуждение участника:Chalker|обсуждение]]) 23:11, 17 декабря 2016 (MSK)
** Условие останова описано в пункте 1.1 (четвертый подпункт)
* 1.2 — n и C не введены. [[Участник:Chalker|Chalker]] ([[Обсуждение участника:Chalker|обсуждение]]) 23:11, 17 декабря 2016 (MSK)
** Исправлено
* 1.2 — в одном предложении написано, что xᵢ — вектор, а через запятую — что это i-тый компонент N-мерного вектора x. Если элементы вектора — это вектора, то, возможно, стоило написать что это матрица? (А матрица ли это?). [[Участник:Chalker|Chalker]] ([[Обсуждение участника:Chalker|обсуждение]]) 23:11, 17 декабря 2016 (MSK)
** Опечатка(тут X в uppercase): xᵢ — вектор, но в тоже время это i-тый компонент N-мерного вектора X (в общем случае X - это вектор из N элементов, которые кластеризуются. С практической точки зрения элементы это тоже вектора)
* 1.2 — Jₘ определён, но больше нигде не используется.
* Пунктуация местами отсутствует в принципе. В том числе и в самом первом предложении. [[Участник:Chalker|Chalker]] ([[Обсуждение участника:Chalker|обсуждение]]) 20:15, 17 декабря 2016 (MSK)
* Размерность входных векторов (p) не входит в сложность? Длина векторов (определена как |X| ниже) не входит в сложность? [[Участник:Chalker|Chalker]] ([[Обсуждение участника:Chalker|обсуждение]]) 20:15, 17 декабря 2016 (MSK)
* Где определены N и D? Во входных данных их нет. [[Участник:Chalker|Chalker]] ([[Обсуждение участника:Chalker|обсуждение]]) 20:15, 17 декабря 2016 (MSK)
* 1.6 — в терминах каких операций вычисляется сложность? [[Участник:Chalker|Chalker]] ([[Обсуждение участника:Chalker|обсуждение]]) 20:15, 17 декабря 2016 (MSK)

----

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

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

2016-12-18T13:24:25Z

Marina abramenkova:

{{Assignment|{{REVISIONUSER}}}}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

<source lang="C++">

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

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

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

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

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

}
return u;
}
</source>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

<references \>

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

2016-12-18T13:15:28Z

Marina abramenkova: /* Математическое описание алгоритма */

{{Assignment|{{REVISIONUSER}}}}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

<source lang="C++">

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

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

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

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

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

}
return u;
}
</source>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

<references \>

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

2016-12-18T13:13:51Z

Marina abramenkova:

{{Assignment|{{REVISIONUSER}}}}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

<source lang="C++">

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

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

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

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

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

}
return u;
}
</source>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

<references \>

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

2016-12-04T13:09:41Z

Marina abramenkova:

{{Assignment}}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

<source lang="C++">

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

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

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

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

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

}
return u;
}
</source>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

<references \>

Файл:FCMclusters color.png

2016-12-04T13:08:50Z

Marina abramenkova: Marina abramenkova загрузил новую версию Файл:FCMclusters color.png

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

2016-12-04T13:05:20Z

Marina abramenkova:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

<source lang="C++">

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

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

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

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

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

}
return u;
}
</source>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

<references \>

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

2016-12-04T13:04:10Z

Marina abramenkova:

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

2016-12-04T13:01:56Z

Marina abramenkova: /* Статья Нечеткий алгоритм С средних */

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

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

2016-12-04T13:00:14Z

Marina abramenkova: /* Масштабируемость алгоритма и его реализации */

Файл:FCMclusters color.png

2016-12-04T12:57:05Z

Marina abramenkova:

Файл:FCMvectors color2.png

2016-12-04T12:56:14Z

Marina abramenkova:

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

2016-12-03T10:36:25Z

Marina abramenkova: /* Статья Нечеткий алгоритм С средних */

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

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

2016-12-03T10:33:25Z

Marina abramenkova: /* Масштабируемость алгоритма и его реализации */

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

<source lang="C++">

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

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

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

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

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

}
return u;
}
</source>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

<references \>

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

2016-12-03T10:31:36Z

Marina abramenkova: /* Масштабируемость алгоритма и его реализации */

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

<source lang="C++">

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

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

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

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

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

}
return u;
}
</source>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

<references \>

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

2016-12-03T09:59:25Z

Marina abramenkova: /* Масштабируемость алгоритма и его реализации */

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

<source lang="C++">

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

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

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

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

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

}
return u;
}
</source>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

<references \>

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

2016-12-03T09:58:11Z

Marina abramenkova: /* Масштабируемость алгоритма и его реализации */

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

<source lang="C++">

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

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

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

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

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

}
return u;
}
</source>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

<references \>

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

2016-12-03T09:44:36Z

Marina abramenkova: /* Масштабируемость алгоритма и его реализации */

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

<source lang="C++">

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

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

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

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

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

}
return u;
}
</source>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

<references \>

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

2016-10-29T09:30:23Z

Marina abramenkova: /* Статья Нечеткий алгоритм С средних */

= Статья [[Нечеткий алгоритм С средних]] =
* не указан вклад каждого автора [[Участник:Coctic|Coctic]] ([[Обсуждение участника:Coctic|обсуждение]]) 12:58, 25 октября 2016 (MSK) - исправлено
* п. 1.9 не приведены оценки объема входных и выходных данных [[Участник:Coctic|Coctic]] ([[Обсуждение участника:Coctic|обсуждение]]) 12:58, 25 октября 2016 (MSK) - исправлено

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

2016-10-29T09:29:19Z

Marina abramenkova:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

<source lang="C++">

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

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

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

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

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

}
return u;
}
</source>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Как видно из предыдущих пунктов, масштабируется данный алгоритм хорошо. С увеличением количества процессоров время работы падает, а с увеличением количества входных данных и количества кластеров - растёт. На рисунках показана масштабируемость алгоритма.
[[File:FCMCOMP1.jpg|thumb|center|1500px|Рисунок 2. Масштабируемость алгоритма. Зависимость сложности алгоритма от количества процессоров и входных данных при фиксированном количестве кластеров.]]
[[File:FCMCOMP2.jpg|thumb|center|1500px|Рисунок 3. Масштабируемость алгоритма. Зависимость сложности алгоритма от количества процессоров и кластеров при фиксированном количестве входных данных.]]

=== Динамические характеристики и эффективность реализации алгоритма ===

=== Выводы для классов архитектур ===

=== Существующие реализации алгоритма ===

Существует множество реализаций данного алгоритма. Рассмотрим некоторые из них:

- Например, тут: https://habrahabr.ru/post/208496/
<ref>Нестер А. "Алгоритм нечёткой кластеризации fuzzy c-means на PHP". [html](https://habrahabr.ru/post/208496/)</ref>
приведено краткое описание алгоритма и приведена его реализация на php. В данной статье довольно подробно расписан каждый шаг алгоритма и приведён соответствующий ему фрагмент кода.

- Тут: http://num-meth.srcc.msu.ru/zhurnal/tom_2012/v13r207.html
<ref>Миниахметов Р.М., Цымблер М.Л. "Интеграция алгоритма кластеризации Fuzzy c-Means в PostgreSQL". [html](http://num-meth.srcc.msu.ru/zhurnal/tom_2012/v13r207.html)</ref>
приводится реализация алгоритма для PostgreSQL, а также прилагается скрипт внедрения алгоритма.

== Литература ==

<references \>

Участник:Demon smd/Нечеткий алгоритм С средних

2016-10-29T09:27:18Z

Marina abramenkova: /* Входные и выходные данные алгоритма */

{{algorithm
| name = Нечеткий алгоритм C средних (Fuzzy C-means)
| serial_complexity = <math>O(C^2*N*D*IterNumber)</math>
| pf_height = <math>O(\log_{2}C^4*|X|^3) * IterNumber</math>
| pf_width = <math>O(C^2*|X|)</math>
| input_data = <math>|X|*p</math>, где <math>p</math> - размерность входных векторов
| output_data = <math>|X|*C </math>
}}

Авторы описания алгоритма:
[[Участник:Demon smd|Д.А.Гуськов]]
[[Участник:marina abramenkova|М.А.Абраменкова]]
Во все разделы вклад равноценный.

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===
Нечёткий алгоритм кластеризации С-средних был разработан (для случая m=2) J.C. Dunn в 1973 г.
<ref>Dunn, J. C. (1973-01-01). "A Fuzzy Relative of the ISODATA Process and Its Use in Detecting Compact Well-Separated Clusters". Journal of Cybernetics. 3 (3): 32–57. doi:10.1080/01969727308546046. ISSN 0022-0280.</ref>
и усовершенствован (для случая m>1)
J.C. Bezdek в 1981 г. <ref>Bezdek, James C. (1981). Pattern Recognition with Fuzzy Objective Function Algorithms. ISBN 0-306-40671-3.</ref>
. В отличие от алгоритма c-means данный метод кластеризации предполагает, что входные данные могут принадлежать более, чем одному кластеру одновременно.
Алгоритм получает на вход набор кластеризуемых векторов, количество кластеров, коэффициент неопределённости m и коэффициент <math>\varepsilon > 0</math>, определяющий точность алгоритма. На выходе алгоритма получаем матрицу вероятностей принадлежности каждого входного вектора каждому кластеру.

Нечеткий алгоритм С средних заключается в следующем. Изначально для каждого вектора определяется случайным образом вероятность принадлежности вектора к каждому кластеру. Далее запускается итерационный процесс, на каждой итерации которого происходит:

1) расчёт центров кластеров

2) расчёт Евклидова расстояния от каждого вектора до центра каждого кластера

3) расчёт и нормализация коэффициентов принадлежности векторов кластерам

4) расчёт значения решающей функции и сравнение этого значения со значением решающей функции на предшествующей итерации: если разница этих значений меньше установленного значения, то алгоритм прекращает работу (решающая функция возвращает сумму всех Евклидовых расстояний каждого объекта к каждому центру кластера умноженному на коэффициент принадлежности)

=== Математическое описание алгоритма ===
Нечеткий алгоритм С средних минимизирует величину:
:<math>
\begin{align}
J_{m} = \sum_{i = 1}^{N}\sum_{j = 1}^{C}u_{i,j}^m\left\Vert{x_{i}-c_{j}}\right\|^2 & , & & 1 \le m \le \infty , \\
\end{align}
</math>
где m - это действительное число не меньше единицы, <math>u_{i,j}</math> - коэффициент принадлежности вектора <math>x_{i}</math> к кластеру <math>c_{j}</math>, <math>x_{i}</math> - <math>i</math>-ый компонент <math>N</math>-мерного вектора <math>x</math>, <math>c_{j}</math>
- центр <math>j</math>-ого кластера, а <math>\left\Vert{*}\right\|</math> - это любая норма, определяющая расстояние от вектора до центра кластера.
Нечёткое разбиение входных данных на кластеры производится итеративной оптимизацией вышеуказанной функции с обновлением коэффициента принадлежности <math>u_{i,j}</math> и переопределением центра кластера <math>c_{j}</math> на каждой итерации алгоритма.

==== Вычисляемые данные на каждой итерации ====
* Центры кластеров рассчитываются по следующей формуле: <math>c_{j} = {{\sum_{i = 1}^{n}{u_{i,j}^m} * x_{i}} \over {\sum_{i = 1}^{n}{u_{i,j}^m}}}</math>, где <math>u_{i,j}</math> — коэффициент принадлежности <math>x_{i}</math> вектора к кластеру <math>c_{j}</math>.

* Коэффициент принадлежности рассчитывается по формуле: <math>u_{i,j} = {1 \over \sum_{k = 1}^{C}{({\left\Vert{x_{i}-c_{j}}\right\| \over \left\Vert{x_{i}-c_{k}}\right\|})}^{2 \over m-1}}</math>

* Решающая функция рассчитывается по формуле: <math>\max_{i,j}(|u_{i,j}^{(k)} - u_{i,j}^{(k-1)}|)</math>, где <math>k</math> - номер итерации алгоритма

=== Вычислительное ядро алгоритма ===

Ядром алгоритма является:
* вычисление новых центров кластеров
* для каждого входного вектора вычисление Евклидова расстояния до центров кластеров, а также коэффициента принадлежности кластерам
* вычисление решающей функции

=== Макроструктура алгоритма ===

В каждой итерации алгоритма происходит 3 основных действия описанных в п. 1.2.1:
*вычисление центров кластеров
*вычисление коэффициентов принадлежности
*вычисление решающей функции
Подробное описание макроструктур в виде кода приведено в пункте 1.5

=== Схема реализации последовательного алгоритма ===

Схему реализации последовательного алгоритма можно описать на C++ следующим образом:

<source lang="C++">

FCM (X[], C, m, eps){
float deside = 0;
float newDeside = 0;
generateMembershipDegree(); //заполняет uPrev[][] случайными нормрованными коэффициентами
while (true){
newDeside = deside;

//вычисление центров кластеров
for (int j=0; j<C; j++){ //для каждого кластера
float numerator = 0;
float denumerator = 0;
for (int i=0; i<X.size(); i++){ //для каждого вектора
numerator+=pow(u[i][j], m) * x[i];
denumerator+=pow(u[i][j], m);
}
c[j] = numerator / denumerator;
}

//вычисление коэффициентов u[][]
for (int i=0; i<X.size(); i++) //для каждого вектора
for (int j=0; j<C; j++){ //для каждого кластера
sum = 0;
for (int k=0; k<C; k++)
sum+= pow( dist(x[i], c[j]) / dist(x[i], c[k]), 2/(m-1));
u[i][j] = 1/sum
}

//определения максимального различия между u[][] и uPrev[][]
float max = 0;
for (int i=0; i<X.size(); i++) //для каждого вектора
for (int j=0; j<C; j++){ //для каждого кластера
if (abs(uPrev[i][j]-u[i][j])>max)
max = abs(uPrev[i][j]-u[i][j]);

if (eps <= max)
for (int i=0; i<X.size(); i++) //для каждого вектора
for (int j=0; j<C; j++){ //для каждого кластера
uPrev[i][j]=u[i][j];
else
break;

}
return u;
}
</source>

=== Последовательная сложность алгоритма ===

Последовательная сложность всего алгоритма складывается из сложности операций на каждой итерации умноженную на количество итераций. Так как в данном алгоритме количество итераций не является фиксированным и зависит от:
* параметра <math>\varepsilon</math>
* набора входных векторов <math>x</math>
* выбора начальных коэффициентов <math>u</math>
то в данном пункте будет приведена сложность одной итерации относительно количества входных векторов.
Как видно из предыдущего пункта, для вычисления центров кластеров требуется <math>O(2*C*|X|)</math> операций, для определения коэффициентов <math>u</math> - <math>O(C^2*|X|)</math> операций, а для вычисления решающей функции - <math>O(2*C*|X|)</math> операций, где <math>|X|</math> - число входных векторов, а <math>C</math> - количество кластеров.

Таким образом итоговая сложность одной итерации составляет <math>O(C^2*|X|)</math>.

=== Информационный граф ===

Как видно из пункта 1.5, на каждом действии каждой итерации алгоритма все операции, выполняющиеся в цикле, не зависят друг от друга и могут быть распараллелены. Это показано на Рисунке 1.

[[File:FCMIG.png|thumb|center|1200px|Рисунок 1. Информационный граф алгоритма. (1)-(7) - это наборы последовательных действий (например, (2) - последовательные операции деления, взятия адреса и присваивания).]]

=== Ресурс параллелизма алгоритма ===

На каждом ярусе ярусно-параллельной формы алгоритма будет располагаться конечное число элементарных операций, например, взятие адреса, сложение или возведение в степень. Информационый граф из п.1.7 изображает свёрнутую ярусно-параллельную форму алгоритма.

Сложность алгоритма будем рассчитывать в предположении, что число вычислительных ядер стремится к бесконечности. Как видно из информационного графа, параллельная сложность вычисления центров кластеров составляет <math>O(\log_{2} C*|X|)</math>, вычисления коэффициентов принадлежности - <math>O(\log_{2} C^2*|X|)</math>, а вычисления решающей функции - не больше чем <math>O(\log_{2} C*|X|)</math>.

Таким образом параллельная сложность итерации алгоритма составляет <math>O(\log_{2} C^4*|X|^3)</math>.

Так как задачи, решаемые в макроструктуре алгоритма могут быть сведены к задачам вычисления суммы элементов массива и максимального элемента массива, то на <math>i</math>-ом ярусе графа будет находиться <math>{N}\over{2^i}</math> операции, где N - количество элементов массива.

=== Входные и выходные данные алгоритма ===

==== Входные данные алгоритма ====
* <math>X</math> - набор из <math>|X|</math> входных векторов длины <math>p</math>
* <math>C</math> - количество кластеров
* <math>m</math> - коэффициент неопределённости
* <math>\varepsilon > 0</math> - коэффициент, определяющий точность алгоритма.

Объем входных данных: <math>|X|*p+3</math>

==== Выходные данные алгоритма ====
* <math>u</math> - матрица принадлежности векторов кластерам

Объем выходных данных: <math>|X|*C</math>

=== Свойства алгоритма ===

Увеличение скорости работы алгоритма при распараллеливании на бесконечном количестве процессоров составляет <math>O({{C^2*|X|}\over{\log_{2} (C^4*|X|^3)}})</math>. Например, для разбиения 1000 элементов на 10 кластеров производительность параллельного алгоритма будет в 2315 раз больше, а на 20 кластеров - уже в 8477 раз.

== Программная реализация алгоритма ==

=== Особенности реализации последовательного алгоритма ===

=== Локальность данных и вычислений ===

=== Возможные способы и особенности параллельной реализации алгоритма ===

=== Масштабируемость алгоритма и его реализации ===

Как видно из предыдущих пунктов, масштабируется данный алгоритм хорошо. С увеличением количества процессоров время работы падает, а с увеличением количества входных данных и количества кластеров - растёт. На рисунках показана масштабируемость алгоритма.
[[File:FCMCOMP1.jpg|thumb|center|1500px|Рисунок 2. Масштабируемость алгоритма. Зависимость сложности алгоритма от количества процессоров и входных данных при фиксированном количестве кластеров.]]
[[File:FCMCOMP2.jpg|thumb|center|1500px|Рисунок 3. Масштабируемость алгоритма. Зависимость сложности алгоритма от количества процессоров и кластеров при фиксированном количестве входных данных.]]

=== Динамические характеристики и эффективность реализации алгоритма ===

=== Выводы для классов архитектур ===

=== Существующие реализации алгоритма ===

Существует множество реализаций данного алгоритма. Рассмотрим некоторые из них:

- Например, тут: https://habrahabr.ru/post/208496/
<ref>Нестер А. "Алгоритм нечёткой кластеризации fuzzy c-means на PHP". [html](https://habrahabr.ru/post/208496/)</ref>
приведено краткое описание алгоритма и приведена его реализация на php. В данной статье довольно подробно расписан каждый шаг алгоритма и приведён соответствующий ему фрагмент кода.

- Тут: http://num-meth.srcc.msu.ru/zhurnal/tom_2012/v13r207.html
<ref>Миниахметов Р.М., Цымблер М.Л. "Интеграция алгоритма кластеризации Fuzzy c-Means в PostgreSQL". [html](http://num-meth.srcc.msu.ru/zhurnal/tom_2012/v13r207.html)</ref>
приводится реализация алгоритма для PostgreSQL, а также прилагается скрипт внедрения алгоритма.

== Литература ==

<references \>

Участник:Demon smd/Нечеткий алгоритм С средних

2016-10-29T09:25:07Z

Marina abramenkova: /* Информационный граф */

{{algorithm
| name = Нечеткий алгоритм C средних (Fuzzy C-means)
| serial_complexity = <math>O(C^2*N*D*IterNumber)</math>
| pf_height = <math>O(\log_{2}C^4*|X|^3) * IterNumber</math>
| pf_width = <math>O(C^2*|X|)</math>
| input_data = <math>|X|*p</math>, где <math>p</math> - размерность входных векторов
| output_data = <math>|X|*C </math>
}}

Авторы описания алгоритма:
[[Участник:Demon smd|Д.А.Гуськов]]
[[Участник:marina abramenkova|М.А.Абраменкова]]
Во все разделы вклад равноценный.

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===
Нечёткий алгоритм кластеризации С-средних был разработан (для случая m=2) J.C. Dunn в 1973 г.
<ref>Dunn, J. C. (1973-01-01). "A Fuzzy Relative of the ISODATA Process and Its Use in Detecting Compact Well-Separated Clusters". Journal of Cybernetics. 3 (3): 32–57. doi:10.1080/01969727308546046. ISSN 0022-0280.</ref>
и усовершенствован (для случая m>1)
J.C. Bezdek в 1981 г. <ref>Bezdek, James C. (1981). Pattern Recognition with Fuzzy Objective Function Algorithms. ISBN 0-306-40671-3.</ref>
. В отличие от алгоритма c-means данный метод кластеризации предполагает, что входные данные могут принадлежать более, чем одному кластеру одновременно.
Алгоритм получает на вход набор кластеризуемых векторов, количество кластеров, коэффициент неопределённости m и коэффициент <math>\varepsilon > 0</math>, определяющий точность алгоритма. На выходе алгоритма получаем матрицу вероятностей принадлежности каждого входного вектора каждому кластеру.

Нечеткий алгоритм С средних заключается в следующем. Изначально для каждого вектора определяется случайным образом вероятность принадлежности вектора к каждому кластеру. Далее запускается итерационный процесс, на каждой итерации которого происходит:

1) расчёт центров кластеров

2) расчёт Евклидова расстояния от каждого вектора до центра каждого кластера

3) расчёт и нормализация коэффициентов принадлежности векторов кластерам

4) расчёт значения решающей функции и сравнение этого значения со значением решающей функции на предшествующей итерации: если разница этих значений меньше установленного значения, то алгоритм прекращает работу (решающая функция возвращает сумму всех Евклидовых расстояний каждого объекта к каждому центру кластера умноженному на коэффициент принадлежности)

=== Математическое описание алгоритма ===
Нечеткий алгоритм С средних минимизирует величину:
:<math>
\begin{align}
J_{m} = \sum_{i = 1}^{N}\sum_{j = 1}^{C}u_{i,j}^m\left\Vert{x_{i}-c_{j}}\right\|^2 & , & & 1 \le m \le \infty , \\
\end{align}
</math>
где m - это действительное число не меньше единицы, <math>u_{i,j}</math> - коэффициент принадлежности вектора <math>x_{i}</math> к кластеру <math>c_{j}</math>, <math>x_{i}</math> - <math>i</math>-ый компонент <math>N</math>-мерного вектора <math>x</math>, <math>c_{j}</math>
- центр <math>j</math>-ого кластера, а <math>\left\Vert{*}\right\|</math> - это любая норма, определяющая расстояние от вектора до центра кластера.
Нечёткое разбиение входных данных на кластеры производится итеративной оптимизацией вышеуказанной функции с обновлением коэффициента принадлежности <math>u_{i,j}</math> и переопределением центра кластера <math>c_{j}</math> на каждой итерации алгоритма.

==== Вычисляемые данные на каждой итерации ====
* Центры кластеров рассчитываются по следующей формуле: <math>c_{j} = {{\sum_{i = 1}^{n}{u_{i,j}^m} * x_{i}} \over {\sum_{i = 1}^{n}{u_{i,j}^m}}}</math>, где <math>u_{i,j}</math> — коэффициент принадлежности <math>x_{i}</math> вектора к кластеру <math>c_{j}</math>.

* Коэффициент принадлежности рассчитывается по формуле: <math>u_{i,j} = {1 \over \sum_{k = 1}^{C}{({\left\Vert{x_{i}-c_{j}}\right\| \over \left\Vert{x_{i}-c_{k}}\right\|})}^{2 \over m-1}}</math>

* Решающая функция рассчитывается по формуле: <math>\max_{i,j}(|u_{i,j}^{(k)} - u_{i,j}^{(k-1)}|)</math>, где <math>k</math> - номер итерации алгоритма

=== Вычислительное ядро алгоритма ===

Ядром алгоритма является:
* вычисление новых центров кластеров
* для каждого входного вектора вычисление Евклидова расстояния до центров кластеров, а также коэффициента принадлежности кластерам
* вычисление решающей функции

=== Макроструктура алгоритма ===

В каждой итерации алгоритма происходит 3 основных действия описанных в п. 1.2.1:
*вычисление центров кластеров
*вычисление коэффициентов принадлежности
*вычисление решающей функции
Подробное описание макроструктур в виде кода приведено в пункте 1.5

=== Схема реализации последовательного алгоритма ===

Схему реализации последовательного алгоритма можно описать на C++ следующим образом:

<source lang="C++">

FCM (X[], C, m, eps){
float deside = 0;
float newDeside = 0;
generateMembershipDegree(); //заполняет uPrev[][] случайными нормрованными коэффициентами
while (true){
newDeside = deside;

//вычисление центров кластеров
for (int j=0; j<C; j++){ //для каждого кластера
float numerator = 0;
float denumerator = 0;
for (int i=0; i<X.size(); i++){ //для каждого вектора
numerator+=pow(u[i][j], m) * x[i];
denumerator+=pow(u[i][j], m);
}
c[j] = numerator / denumerator;
}

//вычисление коэффициентов u[][]
for (int i=0; i<X.size(); i++) //для каждого вектора
for (int j=0; j<C; j++){ //для каждого кластера
sum = 0;
for (int k=0; k<C; k++)
sum+= pow( dist(x[i], c[j]) / dist(x[i], c[k]), 2/(m-1));
u[i][j] = 1/sum
}

//определения максимального различия между u[][] и uPrev[][]
float max = 0;
for (int i=0; i<X.size(); i++) //для каждого вектора
for (int j=0; j<C; j++){ //для каждого кластера
if (abs(uPrev[i][j]-u[i][j])>max)
max = abs(uPrev[i][j]-u[i][j]);

if (eps <= max)
for (int i=0; i<X.size(); i++) //для каждого вектора
for (int j=0; j<C; j++){ //для каждого кластера
uPrev[i][j]=u[i][j];
else
break;

}
return u;
}
</source>

=== Последовательная сложность алгоритма ===

Последовательная сложность всего алгоритма складывается из сложности операций на каждой итерации умноженную на количество итераций. Так как в данном алгоритме количество итераций не является фиксированным и зависит от:
* параметра <math>\varepsilon</math>
* набора входных векторов <math>x</math>
* выбора начальных коэффициентов <math>u</math>
то в данном пункте будет приведена сложность одной итерации относительно количества входных векторов.
Как видно из предыдущего пункта, для вычисления центров кластеров требуется <math>O(2*C*|X|)</math> операций, для определения коэффициентов <math>u</math> - <math>O(C^2*|X|)</math> операций, а для вычисления решающей функции - <math>O(2*C*|X|)</math> операций, где <math>|X|</math> - число входных векторов, а <math>C</math> - количество кластеров.

Таким образом итоговая сложность одной итерации составляет <math>O(C^2*|X|)</math>.

=== Информационный граф ===

Как видно из пункта 1.5, на каждом действии каждой итерации алгоритма все операции, выполняющиеся в цикле, не зависят друг от друга и могут быть распараллелены. Это показано на Рисунке 1.

[[File:FCMIG.png|thumb|center|1200px|Рисунок 1. Информационный граф алгоритма. (1)-(7) - это наборы последовательных действий (например, (2) - последовательные операции деления, взятия адреса и присваивания).]]

=== Ресурс параллелизма алгоритма ===

На каждом ярусе ярусно-параллельной формы алгоритма будет располагаться конечное число элементарных операций, например, взятие адреса, сложение или возведение в степень. Информационый граф из п.1.7 изображает свёрнутую ярусно-параллельную форму алгоритма.

Сложность алгоритма будем рассчитывать в предположении, что число вычислительных ядер стремится к бесконечности. Как видно из информационного графа, параллельная сложность вычисления центров кластеров составляет <math>O(\log_{2} C*|X|)</math>, вычисления коэффициентов принадлежности - <math>O(\log_{2} C^2*|X|)</math>, а вычисления решающей функции - не больше чем <math>O(\log_{2} C*|X|)</math>.

Таким образом параллельная сложность итерации алгоритма составляет <math>O(\log_{2} C^4*|X|^3)</math>.

Так как задачи, решаемые в макроструктуре алгоритма могут быть сведены к задачам вычисления суммы элементов массива и максимального элемента массива, то на <math>i</math>-ом ярусе графа будет находиться <math>{N}\over{2^i}</math> операции, где N - количество элементов массива.

=== Входные и выходные данные алгоритма ===

==== Входные данные алгоритма ====
* <math>X</math> - набор из <math>|X|</math> входных векторов длины <math>p</math>
* <math>C</math> - количество кластеров
* <math>m</math> - коэффициент неопределённости
* <math>\varepsilon > 0</math> - коэффициент, определяющий точность алгоритма.

Объем входных данных: <math>kp</math> (не считая трех коэффициентов)

==== Выходные данные алгоритма ====
* <math>u</math> - матрица принадлежности векторов кластерам

Объем выходных данных: <math>kC</math>

=== Свойства алгоритма ===

Увеличение скорости работы алгоритма при распараллеливании на бесконечном количестве процессоров составляет <math>O({{C^2*|X|}\over{\log_{2} (C^4*|X|^3)}})</math>. Например, для разбиения 1000 элементов на 10 кластеров производительность параллельного алгоритма будет в 2315 раз больше, а на 20 кластеров - уже в 8477 раз.

== Программная реализация алгоритма ==

=== Особенности реализации последовательного алгоритма ===

=== Локальность данных и вычислений ===

=== Возможные способы и особенности параллельной реализации алгоритма ===

=== Масштабируемость алгоритма и его реализации ===

Как видно из предыдущих пунктов, масштабируется данный алгоритм хорошо. С увеличением количества процессоров время работы падает, а с увеличением количества входных данных и количества кластеров - растёт. На рисунках показана масштабируемость алгоритма.
[[File:FCMCOMP1.jpg|thumb|center|1500px|Рисунок 2. Масштабируемость алгоритма. Зависимость сложности алгоритма от количества процессоров и входных данных при фиксированном количестве кластеров.]]
[[File:FCMCOMP2.jpg|thumb|center|1500px|Рисунок 3. Масштабируемость алгоритма. Зависимость сложности алгоритма от количества процессоров и кластеров при фиксированном количестве входных данных.]]

=== Динамические характеристики и эффективность реализации алгоритма ===

=== Выводы для классов архитектур ===

=== Существующие реализации алгоритма ===

Существует множество реализаций данного алгоритма. Рассмотрим некоторые из них:

- Например, тут: https://habrahabr.ru/post/208496/
<ref>Нестер А. "Алгоритм нечёткой кластеризации fuzzy c-means на PHP". [html](https://habrahabr.ru/post/208496/)</ref>
приведено краткое описание алгоритма и приведена его реализация на php. В данной статье довольно подробно расписан каждый шаг алгоритма и приведён соответствующий ему фрагмент кода.

- Тут: http://num-meth.srcc.msu.ru/zhurnal/tom_2012/v13r207.html
<ref>Миниахметов Р.М., Цымблер М.Л. "Интеграция алгоритма кластеризации Fuzzy c-Means в PostgreSQL". [html](http://num-meth.srcc.msu.ru/zhurnal/tom_2012/v13r207.html)</ref>
приводится реализация алгоритма для PostgreSQL, а также прилагается скрипт внедрения алгоритма.

== Литература ==

<references \>

Участник:Demon smd/Нечеткий алгоритм С средних

2016-10-29T09:20:20Z

Marina abramenkova:

{{algorithm
| name = Нечеткий алгоритм C средних (Fuzzy C-means)
| serial_complexity = <math>O(C^2*N*D*IterNumber)</math>
| pf_height = <math>O(\log_{2}C^4*|X|^3) * IterNumber</math>
| pf_width = <math>O(C^2*|X|)</math>
| input_data = <math>|X|*p</math>, где <math>p</math> - размерность входных векторов
| output_data = <math>|X|*C </math>
}}

Авторы описания алгоритма:
[[Участник:Demon smd|Д.А.Гуськов]](Информационный граф)
[[Участник:marina abramenkova|М.А.Абраменкова]](Схема реализации последовательного алгоритма)
В остальные разделы вклад равноценный.

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===
Нечёткий алгоритм кластеризации С-средних был разработан (для случая m=2) J.C. Dunn в 1973 г.
<ref>Dunn, J. C. (1973-01-01). "A Fuzzy Relative of the ISODATA Process and Its Use in Detecting Compact Well-Separated Clusters". Journal of Cybernetics. 3 (3): 32–57. doi:10.1080/01969727308546046. ISSN 0022-0280.</ref>
и усовершенствован (для случая m>1)
J.C. Bezdek в 1981 г. <ref>Bezdek, James C. (1981). Pattern Recognition with Fuzzy Objective Function Algorithms. ISBN 0-306-40671-3.</ref>
. В отличие от алгоритма c-means данный метод кластеризации предполагает, что входные данные могут принадлежать более, чем одному кластеру одновременно.
Алгоритм получает на вход набор кластеризуемых векторов, количество кластеров, коэффициент неопределённости m и коэффициент <math>\varepsilon > 0</math>, определяющий точность алгоритма. На выходе алгоритма получаем матрицу вероятностей принадлежности каждого входного вектора каждому кластеру.

Нечеткий алгоритм С средних заключается в следующем. Изначально для каждого вектора определяется случайным образом вероятность принадлежности вектора к каждому кластеру. Далее запускается итерационный процесс, на каждой итерации которого происходит:

1) расчёт центров кластеров

2) расчёт Евклидова расстояния от каждого вектора до центра каждого кластера

3) расчёт и нормализация коэффициентов принадлежности векторов кластерам

4) расчёт значения решающей функции и сравнение этого значения со значением решающей функции на предшествующей итерации: если разница этих значений меньше установленного значения, то алгоритм прекращает работу (решающая функция возвращает сумму всех Евклидовых расстояний каждого объекта к каждому центру кластера умноженному на коэффициент принадлежности)

=== Математическое описание алгоритма ===
Нечеткий алгоритм С средних минимизирует величину:
:<math>
\begin{align}
J_{m} = \sum_{i = 1}^{N}\sum_{j = 1}^{C}u_{i,j}^m\left\Vert{x_{i}-c_{j}}\right\|^2 & , & & 1 \le m \le \infty , \\
\end{align}
</math>
где m - это действительное число не меньше единицы, <math>u_{i,j}</math> - коэффициент принадлежности вектора <math>x_{i}</math> к кластеру <math>c_{j}</math>, <math>x_{i}</math> - <math>i</math>-ый компонент <math>N</math>-мерного вектора <math>x</math>, <math>c_{j}</math>
- центр <math>j</math>-ого кластера, а <math>\left\Vert{*}\right\|</math> - это любая норма, определяющая расстояние от вектора до центра кластера.
Нечёткое разбиение входных данных на кластеры производится итеративной оптимизацией вышеуказанной функции с обновлением коэффициента принадлежности <math>u_{i,j}</math> и переопределением центра кластера <math>c_{j}</math> на каждой итерации алгоритма.

==== Вычисляемые данные на каждой итерации ====
* Центры кластеров рассчитываются по следующей формуле: <math>c_{j} = {{\sum_{i = 1}^{n}{u_{i,j}^m} * x_{i}} \over {\sum_{i = 1}^{n}{u_{i,j}^m}}}</math>, где <math>u_{i,j}</math> — коэффициент принадлежности <math>x_{i}</math> вектора к кластеру <math>c_{j}</math>.

* Коэффициент принадлежности рассчитывается по формуле: <math>u_{i,j} = {1 \over \sum_{k = 1}^{C}{({\left\Vert{x_{i}-c_{j}}\right\| \over \left\Vert{x_{i}-c_{k}}\right\|})}^{2 \over m-1}}</math>

* Решающая функция рассчитывается по формуле: <math>\max_{i,j}(|u_{i,j}^{(k)} - u_{i,j}^{(k-1)}|)</math>, где <math>k</math> - номер итерации алгоритма

=== Вычислительное ядро алгоритма ===

Ядром алгоритма является:
* вычисление новых центров кластеров
* для каждого входного вектора вычисление Евклидова расстояния до центров кластеров, а также коэффициента принадлежности кластерам
* вычисление решающей функции

=== Макроструктура алгоритма ===

В каждой итерации алгоритма происходит 3 основных действия описанных в п. 1.2.1:
*вычисление центров кластеров
*вычисление коэффициентов принадлежности
*вычисление решающей функции
Подробное описание макроструктур в виде кода приведено в пункте 1.5

=== Схема реализации последовательного алгоритма ===

Схему реализации последовательного алгоритма можно описать на C++ следующим образом:

<source lang="C++">

FCM (X[], C, m, eps){
float deside = 0;
float newDeside = 0;
generateMembershipDegree(); //заполняет uPrev[][] случайными нормрованными коэффициентами
while (true){
newDeside = deside;

//вычисление центров кластеров
for (int j=0; j<C; j++){ //для каждого кластера
float numerator = 0;
float denumerator = 0;
for (int i=0; i<X.size(); i++){ //для каждого вектора
numerator+=pow(u[i][j], m) * x[i];
denumerator+=pow(u[i][j], m);
}
c[j] = numerator / denumerator;
}

//вычисление коэффициентов u[][]
for (int i=0; i<X.size(); i++) //для каждого вектора
for (int j=0; j<C; j++){ //для каждого кластера
sum = 0;
for (int k=0; k<C; k++)
sum+= pow( dist(x[i], c[j]) / dist(x[i], c[k]), 2/(m-1));
u[i][j] = 1/sum
}

//определения максимального различия между u[][] и uPrev[][]
float max = 0;
for (int i=0; i<X.size(); i++) //для каждого вектора
for (int j=0; j<C; j++){ //для каждого кластера
if (abs(uPrev[i][j]-u[i][j])>max)
max = abs(uPrev[i][j]-u[i][j]);

if (eps <= max)
for (int i=0; i<X.size(); i++) //для каждого вектора
for (int j=0; j<C; j++){ //для каждого кластера
uPrev[i][j]=u[i][j];
else
break;

}
return u;
}
</source>

=== Последовательная сложность алгоритма ===

Последовательная сложность всего алгоритма складывается из сложности операций на каждой итерации умноженную на количество итераций. Так как в данном алгоритме количество итераций не является фиксированным и зависит от:
* параметра <math>\varepsilon</math>
* набора входных векторов <math>x</math>
* выбора начальных коэффициентов <math>u</math>
то в данном пункте будет приведена сложность одной итерации относительно количества входных векторов.
Как видно из предыдущего пункта, для вычисления центров кластеров требуется <math>O(2*C*|X|)</math> операций, для определения коэффициентов <math>u</math> - <math>O(C^2*|X|)</math> операций, а для вычисления решающей функции - <math>O(2*C*|X|)</math> операций, где <math>|X|</math> - число входных векторов, а <math>C</math> - количество кластеров.

Таким образом итоговая сложность одной итерации составляет <math>O(C^2*|X|)</math>.

=== Информационный граф ===

Как видно из пункта 1.5, на каждом действии каждой итерации алгоритма все операции, выполняющиеся в цикле, не зависят друг от друга и могут быть распаралелены. Это показано на Рисунке 1.

[[File:FCMIG.png|thumb|center|1200px|Рисунок 1. Информационный граф алгоритма. (1)-(7) - это наборы последовательных действий (например, (2) - последовательные операции деления, взятия адреса и присваивания).]]

=== Ресурс параллелизма алгоритма ===

На каждом ярусе ярусно-параллельной формы алгоритма будет располагаться конечное число элементарных операций, например, взятие адреса, сложение или возведение в степень. Информационый граф из п.1.7 изображает свёрнутую ярусно-параллельную форму алгоритма.

Сложность алгоритма будем рассчитывать в предположении, что число вычислительных ядер стремится к бесконечности. Как видно из информационного графа, параллельная сложность вычисления центров кластеров составляет <math>O(\log_{2} C*|X|)</math>, вычисления коэффициентов принадлежности - <math>O(\log_{2} C^2*|X|)</math>, а вычисления решающей функции - не больше чем <math>O(\log_{2} C*|X|)</math>.

Таким образом параллельная сложность итерации алгоритма составляет <math>O(\log_{2} C^4*|X|^3)</math>.

Так как задачи, решаемые в макроструктуре алгоритма могут быть сведены к задачам вычисления суммы элементов массива и максимального элемента массива, то на <math>i</math>-ом ярусе графа будет находиться <math>{N}\over{2^i}</math> операции, где N - количество элементов массива.

=== Входные и выходные данные алгоритма ===

==== Входные данные алгоритма ====
* <math>X</math> - набор из <math>|X|</math> входных векторов длины <math>p</math>
* <math>C</math> - количество кластеров
* <math>m</math> - коэффициент неопределённости
* <math>\varepsilon > 0</math> - коэффициент, определяющий точность алгоритма.

Объем входных данных: <math>kp</math> (не считая трех коэффициентов)

==== Выходные данные алгоритма ====
* <math>u</math> - матрица принадлежности векторов кластерам

Объем выходных данных: <math>kC</math>

=== Свойства алгоритма ===

Увеличение скорости работы алгоритма при распараллеливании на бесконечном количестве процессоров составляет <math>O({{C^2*|X|}\over{\log_{2} (C^4*|X|^3)}})</math>. Например, для разбиения 1000 элементов на 10 кластеров производительность параллельного алгоритма будет в 2315 раз больше, а на 20 кластеров - уже в 8477 раз.

== Программная реализация алгоритма ==

=== Особенности реализации последовательного алгоритма ===

=== Локальность данных и вычислений ===

=== Возможные способы и особенности параллельной реализации алгоритма ===

=== Масштабируемость алгоритма и его реализации ===

Как видно из предыдущих пунктов, масштабируется данный алгоритм хорошо. С увеличением количества процессоров время работы падает, а с увеличением количества входных данных и количества кластеров - растёт. На рисунках показана масштабируемость алгоритма.
[[File:FCMCOMP1.jpg|thumb|center|1500px|Рисунок 2. Масштабируемость алгоритма. Зависимость сложности алгоритма от количества процессоров и входных данных при фиксированном количестве кластеров.]]
[[File:FCMCOMP2.jpg|thumb|center|1500px|Рисунок 3. Масштабируемость алгоритма. Зависимость сложности алгоритма от количества процессоров и кластеров при фиксированном количестве входных данных.]]

=== Динамические характеристики и эффективность реализации алгоритма ===

=== Выводы для классов архитектур ===

=== Существующие реализации алгоритма ===

Существует множество реализаций данного алгоритма. Рассмотрим некоторые из них:

- Например, тут: https://habrahabr.ru/post/208496/
<ref>Нестер А. "Алгоритм нечёткой кластеризации fuzzy c-means на PHP". [html](https://habrahabr.ru/post/208496/)</ref>
приведено краткое описание алгоритма и приведена его реализация на php. В данной статье довольно подробно расписан каждый шаг алгоритма и приведён соответствующий ему фрагмент кода.

- Тут: http://num-meth.srcc.msu.ru/zhurnal/tom_2012/v13r207.html
<ref>Миниахметов Р.М., Цымблер М.Л. "Интеграция алгоритма кластеризации Fuzzy c-Means в PostgreSQL". [html](http://num-meth.srcc.msu.ru/zhurnal/tom_2012/v13r207.html)</ref>
приводится реализация алгоритма для PostgreSQL, а также прилагается скрипт внедрения алгоритма.

== Литература ==

<references \>

Участник:Demon smd/Нечеткий алгоритм С средних

2016-10-28T09:45:06Z

Marina abramenkova:

{{algorithm
| name = Нечеткий алгоритм C средних (Fuzzy C-means)
| serial_complexity = <math>O(C^2*N*D*IterNumber)</math>
| pf_height = <math>O(\log_{2}C^4*|X|^3) * IterNumber</math>
| pf_width = <math>O(C^2*|X|)</math>
| input_data = <math>|X|*C </math>
| output_data = <math>|X|*C </math>
}}

Авторы описания алгоритма:
[[Участник:Demon smd|Д.А.Гуськов]](Информационный граф)
[[Участник:marina abramenkova|М.А.Абраменкова]](Схема реализации последовательного алгоритма)
В остальные разделы вклад равноценный.

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===
Нечёткий алгоритм кластеризации С-средних был разработан (для случая m=2) J.C. Dunn в 1973 г.
<ref>Dunn, J. C. (1973-01-01). "A Fuzzy Relative of the ISODATA Process and Its Use in Detecting Compact Well-Separated Clusters". Journal of Cybernetics. 3 (3): 32–57. doi:10.1080/01969727308546046. ISSN 0022-0280.</ref>
и усовершенствован (для случая m>1)
J.C. Bezdek в 1981 г. <ref>Bezdek, James C. (1981). Pattern Recognition with Fuzzy Objective Function Algorithms. ISBN 0-306-40671-3.</ref>
. В отличие от алгоритма c-means данный метод кластеризации предполагает, что входные данные могут принадлежать более, чем одному кластеру одновременно.
Алгоритм получает на вход набор кластеризуемых векторов, количество кластеров, коэффициент неопределённости m и коэффициент <math>\varepsilon > 0</math>, определяющий точность алгоритма. На выходе алгоритма получаем матрицу вероятностей принадлежности каждого входного вектора каждому кластеру.

Нечеткий алгоритм С средних заключается в следующем. Изначально для каждого вектора определяется случайным образом вероятность принадлежности вектора к каждому кластеру. Далее запускается итерационный процесс, на каждой итерации которого происходит:

1) расчёт центров кластеров

2) расчёт Евклидова расстояния от каждого вектора до центра каждого кластера

3) расчёт и нормализация коэффициентов принадлежности векторов кластерам

4) расчёт значения решающей функции и сравнение этого значения со значением решающей функции на предшествующей итерации: если разница этих значений меньше установленного значения, то алгоритм прекращает работу (решающая функция возвращает сумму всех Евклидовых расстояний каждого объекта к каждому центру кластера умноженному на коэффициент принадлежности)

=== Математическое описание алгоритма ===
Нечеткий алгоритм С средних минимизирует величину:
:<math>
\begin{align}
J_{m} = \sum_{i = 1}^{N}\sum_{j = 1}^{C}u_{i,j}^m\left\Vert{x_{i}-c_{j}}\right\|^2 & , & & 1 \le m \le \infty , \\
\end{align}
</math>
где m - это действительное число не меньше единицы, <math>u_{i,j}</math> - коэффициент принадлежности вектора <math>x_{i}</math> к кластеру <math>c_{j}</math>, <math>x_{i}</math> - <math>i</math>-ый компонент <math>N</math>-мерного вектора <math>x</math>, <math>c_{j}</math>
- центр <math>j</math>-ого кластера, а <math>\left\Vert{*}\right\|</math> - это любая норма, определяющая расстояние от вектора до центра кластера.
Нечёткое разбиение входных данных на кластеры производится итеративной оптимизацией вышеуказанной функции с обновлением коэффициента принадлежности <math>u_{i,j}</math> и переопределением центра кластера <math>c_{j}</math> на каждой итерации алгоритма.

==== Вычисляемые данные на каждой итерации ====
* Центры кластеров рассчитываются по следующей формуле: <math>c_{j} = {{\sum_{i = 1}^{n}{u_{i,j}^m} * x_{i}} \over {\sum_{i = 1}^{n}{u_{i,j}^m}}}</math>, где <math>u_{i,j}</math> — коэффициент принадлежности <math>x_{i}</math> вектора к кластеру <math>c_{j}</math>.

* Коэффициент принадлежности рассчитывается по формуле: <math>u_{i,j} = {1 \over \sum_{k = 1}^{C}{({\left\Vert{x_{i}-c_{j}}\right\| \over \left\Vert{x_{i}-c_{k}}\right\|})}^{2 \over m-1}}</math>

* Решающая функция рассчитывается по формуле: <math>\max_{i,j}(|u_{i,j}^{(k)} - u_{i,j}^{(k-1)}|)</math>, где <math>k</math> - номер итерации алгоритма

=== Вычислительное ядро алгоритма ===

Ядром алгоритма является:
* вычисление новых центров кластеров
* для каждого входного вектора вычисление Евклидова расстояния до центров кластеров, а также коэффициента принадлежности кластерам
* вычисление решающей функции

=== Макроструктура алгоритма ===

В каждой итерации алгоритма происходит 3 основных действия описанных в п. 1.2.1:
*вычисление центров кластеров
*вычисление коэффициентов принадлежности
*вычисление решающей функции
Подробное описание макроструктур в виде кода приведено в пункте 1.5

=== Схема реализации последовательного алгоритма ===

Схему реализации последовательного алгоритма можно описать на C++ следующим образом:

<source lang="C++">

FCM (X[], C, m, eps){
float deside = 0;
float newDeside = 0;
generateMembershipDegree(); //заполняет uPrev[][] случайными нормрованными коэффициентами
while (true){
newDeside = deside;

//вычисление центров кластеров
for (int j=0; j<C; j++){ //для каждого кластера
float numerator = 0;
float denumerator = 0;
for (int i=0; i<X.size(); i++){ //для каждого вектора
numerator+=pow(u[i][j], m) * x[i];
denumerator+=pow(u[i][j], m);
}
c[j] = numerator / denumerator;
}

//вычисление коэффициентов u[][]
for (int i=0; i<X.size(); i++) //для каждого вектора
for (int j=0; j<C; j++){ //для каждого кластера
sum = 0;
for (int k=0; k<C; k++)
sum+= pow( dist(x[i], c[j]) / dist(x[i], c[k]), 2/(m-1));
u[i][j] = 1/sum
}

//определения максимального различия между u[][] и uPrev[][]
float max = 0;
for (int i=0; i<X.size(); i++) //для каждого вектора
for (int j=0; j<C; j++){ //для каждого кластера
if (abs(uPrev[i][j]-u[i][j])>max)
max = abs(uPrev[i][j]-u[i][j]);

if (eps <= max)
for (int i=0; i<X.size(); i++) //для каждого вектора
for (int j=0; j<C; j++){ //для каждого кластера
uPrev[i][j]=u[i][j];
else
break;

}
return u;
}
</source>

=== Последовательная сложность алгоритма ===

Последовательная сложность всего алгоритма складывается из сложности операций на каждой итерации умноженную на количество итераций. Так как в данном алгоритме количество итераций не является фиксированным и зависит от:
* параметра <math>\varepsilon</math>
* набора входных векторов <math>x</math>
* выбора начальных коэффициентов <math>u</math>
то в данном пункте будет приведена сложность одной итерации относительно количества входных векторов.
Как видно из предыдущего пункта, для вычисления центров кластеров требуется <math>O(2*C*|X|)</math> операций, для определения коэффициентов <math>u</math> - <math>O(C^2*|X|)</math> операций, а для вычисления решающей функции - <math>O(2*C*|X|)</math> операций, где <math>|X|</math> - число входных векторов, а <math>C</math> - количество кластеров.

Таким образом итоговая сложность одной итерации составляет <math>O(C^2*|X|)</math>.

=== Информационный граф ===

Как видно из пункта 1.5, на каждом действии каждой итерации алгоритма все операции, выполняющиеся в цикле, не зависят друг от друга и могут быть распаралелены. Это показано на Рисунке 1.

[[File:FCMIG.png|thumb|center|1200px|Рисунок 1. Информационный граф алгоритма. (1)-(7) - это наборы последовательных действий (например, (2) - последовательные операции деления, взятия адреса и присваивания).]]

=== Ресурс параллелизма алгоритма ===

На каждом ярусе ярусно-параллельной формы алгоритма будет располагаться конечное число элементарных операций, например, взятие адреса, сложение или возведение в степень. Информационый граф из п.1.7 изображает свёрнутую ярусно-параллельную форму алгоритма.

Сложность алгоритма будем рассчитывать в предположении, что число вычислительных ядер стремится к бесконечности. Как видно из информационного графа, параллельная сложность вычисления центров кластеров составляет <math>O(\log_{2} C*|X|)</math>, вычисления коэффициентов принадлежности - <math>O(\log_{2} C^2*|X|)</math>, а вычисления решающей функции - не больше чем <math>O(\log_{2} C*|X|)</math>.

Таким образом параллельная сложность итерации алгоритма составляет <math>O(\log_{2} C^4*|X|^3)</math>.

Так как задачи, решаемые в макроструктуре алгоритма могут быть сведены к задачам вычисления суммы элементов массива и максимального элемента массива, то на <math>i</math>-ом ярусе графа будет находиться <math>{N}\over{2^i}</math> операции, где N - количество элементов массива.

=== Входные и выходные данные алгоритма ===

==== Входные данные алгоритма ====
* <math>x_{i}</math> - набор из <math>k</math> входных векторов длины <math>p</math>
* <math>C</math> - количество кластеров
* <math>m</math> - коэффициент неопределённости
* <math>\varepsilon > 0</math> - коэффициент, определяющий точность алгоритма.

Объем входных данных: <math>kp</math> (не считая трех коэффициентов)

==== Выходные данные алгоритма ====
* <math>u</math> - матрица принадлежности векторов кластерам

Объем выходных данных: <math>kC</math>

=== Свойства алгоритма ===

Увеличение скорости работы алгоритма при распараллеливании на бесконечном количестве процессоров составляет <math>O({{C^2*|X|}\over{\log_{2} (C^4*|X|^3)}})</math>. Например, для разбиения 1000 элементов на 10 кластеров производительность параллельного алгоритма будет в 2315 раз больше, а на 20 кластеров - уже в 8477 раз.

== Программная реализация алгоритма ==

=== Особенности реализации последовательного алгоритма ===

=== Локальность данных и вычислений ===

=== Возможные способы и особенности параллельной реализации алгоритма ===

=== Масштабируемость алгоритма и его реализации ===

Как видно из предыдущих пунктов, масштабируется данный алгоритм хорошо. С увеличением количества процессоров время работы падает, а с увеличением количества входных данных и количества кластеров - растёт. На рисунках показана масштабируемость алгоритма.
[[File:FCMCOMP1.jpg|thumb|center|1500px|Рисунок 2. Масштабируемость алгоритма. Зависимость сложности алгоритма от количества процессоров и входных данных при фиксированном количестве кластеров.]]
[[File:FCMCOMP2.jpg|thumb|center|1500px|Рисунок 3. Масштабируемость алгоритма. Зависимость сложности алгоритма от количества процессоров и кластеров при фиксированном количестве входных данных.]]

=== Динамические характеристики и эффективность реализации алгоритма ===

=== Выводы для классов архитектур ===

=== Существующие реализации алгоритма ===

Существует множество реализаций данного алгоритма. Рассмотрим некоторые из них:

- Например, тут: https://habrahabr.ru/post/208496/
<ref>Нестер А. "Алгоритм нечёткой кластеризации fuzzy c-means на PHP". [html](https://habrahabr.ru/post/208496/)</ref>
приведено краткое описание алгоритма и приведена его реализация на php. В данной статье довольно подробно расписан каждый шаг алгоритма и приведён соответствующий ему фрагмент кода.

- Тут: http://num-meth.srcc.msu.ru/zhurnal/tom_2012/v13r207.html
<ref>Миниахметов Р.М., Цымблер М.Л. "Интеграция алгоритма кластеризации Fuzzy c-Means в PostgreSQL". [html](http://num-meth.srcc.msu.ru/zhurnal/tom_2012/v13r207.html)</ref>
приводится реализация алгоритма для PostgreSQL, а также прилагается скрипт внедрения алгоритма.

== Литература ==

<references \>

Участник:Demon smd/Нечеткий алгоритм С средних

2016-10-28T09:06:35Z

Marina abramenkova: /* Входные и выходные данные алгоритма */

{{algorithm
| name = Нечеткий алгоритм C средних (Fuzzy C-means)
| serial_complexity = <math>O(C^2*N*D*IterNumber)</math>
| pf_height = <math>O(\log_{2}C^4*|X|^3) * IterNumber</math>
| pf_width = <math>O(C^2*|X|)</math>
| input_data = <math>|X|*C </math>
| output_data = <math>|X|*C </math>
}}

Авторы описания алгоритма: [[Участник:Demon smd|Д.А.Гуськов]] [[Участник:marina abramenkova|М.А.Абраменкова]]

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===
Нечёткий алгоритм кластеризации С-средних был разработан (для случая m=2) J.C. Dunn в 1973 г.
<ref>Dunn, J. C. (1973-01-01). "A Fuzzy Relative of the ISODATA Process and Its Use in Detecting Compact Well-Separated Clusters". Journal of Cybernetics. 3 (3): 32–57. doi:10.1080/01969727308546046. ISSN 0022-0280.</ref>
и усовершенствован (для случая m>1)
J.C. Bezdek в 1981 г. <ref>Bezdek, James C. (1981). Pattern Recognition with Fuzzy Objective Function Algorithms. ISBN 0-306-40671-3.</ref>
. В отличие от алгоритма c-means данный метод кластеризации предполагает, что входные данные могут принадлежать более, чем одному кластеру одновременно.
Алгоритм получает на вход набор кластеризуемых векторов, количество кластеров, коэффициент неопределённости m и коэффициент <math>\varepsilon > 0</math>, определяющий точность алгоритма. На выходе алгоритма получаем матрицу вероятностей принадлежности каждого входного вектора каждому кластеру.

Нечеткий алгоритм С средних заключается в следующем. Изначально для каждого вектора определяется случайным образом вероятность принадлежности вектора к каждому кластеру. Далее запускается итерационный процесс, на каждой итерации которого происходит:

1) расчёт центров кластеров

2) расчёт Евклидова расстояния от каждого вектора до центра каждого кластера

3) расчёт и нормализация коэффициентов принадлежности векторов кластерам

4) расчёт значения решающей функции и сравнение этого значения со значением решающей функции на предшествующей итерации: если разница этих значений меньше установленного значения, то алгоритм прекращает работу (решающая функция возвращает сумму всех Евклидовых расстояний каждого объекта к каждому центру кластера умноженному на коэффициент принадлежности)

=== Математическое описание алгоритма ===
Нечеткий алгоритм С средних минимизирует величину:
:<math>
\begin{align}
J_{m} = \sum_{i = 1}^{N}\sum_{j = 1}^{C}u_{i,j}^m\left\Vert{x_{i}-c_{j}}\right\|^2 & , & & 1 \le m \le \infty , \\
\end{align}
</math>
где m - это действительное число не меньше единицы, <math>u_{i,j}</math> - коэффициент принадлежности вектора <math>x_{i}</math> к кластеру <math>c_{j}</math>, <math>x_{i}</math> - <math>i</math>-ый компонент <math>N</math>-мерного вектора <math>x</math>, <math>c_{j}</math>
- центр <math>j</math>-ого кластера, а <math>\left\Vert{*}\right\|</math> - это любая норма, определяющая расстояние от вектора до центра кластера.
Нечёткое разбиение входных данных на кластеры производится итеративной оптимизацией вышеуказанной функции с обновлением коэффициента принадлежности <math>u_{i,j}</math> и переопределением центра кластера <math>c_{j}</math> на каждой итерации алгоритма.

==== Вычисляемые данные на каждой итерации ====
* Центры кластеров рассчитываются по следующей формуле: <math>c_{j} = {{\sum_{i = 1}^{n}{u_{i,j}^m} * x_{i}} \over {\sum_{i = 1}^{n}{u_{i,j}^m}}}</math>, где <math>u_{i,j}</math> — коэффициент принадлежности <math>x_{i}</math> вектора к кластеру <math>c_{j}</math>.

* Коэффициент принадлежности рассчитывается по формуле: <math>u_{i,j} = {1 \over \sum_{k = 1}^{C}{({\left\Vert{x_{i}-c_{j}}\right\| \over \left\Vert{x_{i}-c_{k}}\right\|})}^{2 \over m-1}}</math>

* Решающая функция рассчитывается по формуле: <math>\max_{i,j}(|u_{i,j}^{(k)} - u_{i,j}^{(k-1)}|)</math>, где <math>k</math> - номер итерации алгоритма

=== Вычислительное ядро алгоритма ===

Ядром алгоритма является:
* вычисление новых центров кластеров
* для каждого входного вектора вычисление Евклидова расстояния до центров кластеров, а также коэффициента принадлежности кластерам
* вычисление решающей функции

=== Макроструктура алгоритма ===

В каждой итерации алгоритма происходит 3 основных действия описанных в п. 1.2.1:
*вычисление центров кластеров
*вычисление коэффициентов принадлежности
*вычисление решающей функции
Подробное описание макроструктур в виде кода приведено в пункте 1.5

=== Схема реализации последовательного алгоритма ===

Схему реализации последовательного алгоритма можно описать на C++ следующим образом:

<source lang="C++">

FCM (X[], C, m, eps){
float deside = 0;
float newDeside = 0;
generateMembershipDegree(); //заполняет uPrev[][] случайными нормрованными коэффициентами
while (true){
newDeside = deside;

//вычисление центров кластеров
for (int j=0; j<C; j++){ //для каждого кластера
float numerator = 0;
float denumerator = 0;
for (int i=0; i<X.size(); i++){ //для каждого вектора
numerator+=pow(u[i][j], m) * x[i];
denumerator+=pow(u[i][j], m);
}
c[j] = numerator / denumerator;
}

//вычисление коэффициентов u[][]
for (int i=0; i<X.size(); i++) //для каждого вектора
for (int j=0; j<C; j++){ //для каждого кластера
sum = 0;
for (int k=0; k<C; k++)
sum+= pow( dist(x[i], c[j]) / dist(x[i], c[k]), 2/(m-1));
u[i][j] = 1/sum
}

//определения максимального различия между u[][] и uPrev[][]
float max = 0;
for (int i=0; i<X.size(); i++) //для каждого вектора
for (int j=0; j<C; j++){ //для каждого кластера
if (abs(uPrev[i][j]-u[i][j])>max)
max = abs(uPrev[i][j]-u[i][j]);

if (eps <= max)
for (int i=0; i<X.size(); i++) //для каждого вектора
for (int j=0; j<C; j++){ //для каждого кластера
uPrev[i][j]=u[i][j];
else
break;

}
return u;
}
</source>

=== Последовательная сложность алгоритма ===

Последовательная сложность всего алгоритма складывается из сложности операций на каждой итерации умноженную на количество итераций. Так как в данном алгоритме количество итераций не является фиксированным и зависит от:
* параметра <math>\varepsilon</math>
* набора входных векторов <math>x</math>
* выбора начальных коэффициентов <math>u</math>
то в данном пункте будет приведена сложность одной итерации относительно количества входных векторов.
Как видно из предыдущего пункта, для вычисления центров кластеров требуется <math>O(2*C*|X|)</math> операций, для определения коэффициентов <math>u</math> - <math>O(C^2*|X|)</math> операций, а для вычисления решающей функции - <math>O(2*C*|X|)</math> операций, где <math>|X|</math> - число входных векторов, а <math>C</math> - количество кластеров.

Таким образом итоговая сложность одной итерации составляет <math>O(C^2*|X|)</math>.

=== Информационный граф ===

Как видно из пункта 1.5, на каждом действии каждой итерации алгоритма все операции, выполняющиеся в цикле, не зависят друг от друга и могут быть распаралелены. Это показано на Рисунке 1.

[[File:FCMIG.png|thumb|center|1200px|Рисунок 1. Информационный граф алгоритма. (1)-(7) - это наборы последовательных действий (например, (2) - последовательные операции деления, взятия адреса и присваивания).]]

=== Ресурс параллелизма алгоритма ===

На каждом ярусе ярусно-параллельной формы алгоритма будет располагаться конечное число элементарных операций, например, взятие адреса, сложение или возведение в степень. Информационый граф из п.1.7 изображает свёрнутую ярусно-параллельную форму алгоритма.

Сложность алгоритма будем рассчитывать в предположении, что число вычислительных ядер стремится к бесконечности. Как видно из информационного графа, параллельная сложность вычисления центров кластеров составляет <math>O(\log_{2} C*|X|)</math>, вычисления коэффициентов принадлежности - <math>O(\log_{2} C^2*|X|)</math>, а вычисления решающей функции - не больше чем <math>O(\log_{2} C*|X|)</math>.

Таким образом параллельная сложность итерации алгоритма составляет <math>O(\log_{2} C^4*|X|^3)</math>.

Так как задачи, решаемые в макроструктуре алгоритма могут быть сведены к задачам вычисления суммы элементов массива и максимального элемента массива, то на <math>i</math>-ом ярусе графа будет находиться <math>{N}\over{2^i}</math> операции, где N - количество элементов массива.

=== Входные и выходные данные алгоритма ===

==== Входные данные алгоритма ====
* <math>x_{i}</math> - набор из <math>k</math> входных векторов длины <math>p</math>
* <math>C</math> - количество кластеров
* <math>m</math> - коэффициент неопределённости
* <math>\varepsilon > 0</math> - коэффициент, определяющий точность алгоритма.

Объем входных данных: <math>kp</math> (не считая трех коэффициентов)

==== Выходные данные алгоритма ====
* <math>u</math> - матрица принадлежности векторов кластерам

Объем выходных данных: <math>kC</math>

=== Свойства алгоритма ===

Увеличение скорости работы алгоритма при распараллеливании на бесконечном количестве процессоров составляет <math>O({{C^2*|X|}\over{\log_{2} (C^4*|X|^3)}})</math>. Например, для разбиения 1000 элементов на 10 кластеров производительность параллельного алгоритма будет в 2315 раз больше, а на 20 кластеров - уже в 8477 раз.

== Программная реализация алгоритма ==

=== Особенности реализации последовательного алгоритма ===

=== Локальность данных и вычислений ===

=== Возможные способы и особенности параллельной реализации алгоритма ===

=== Масштабируемость алгоритма и его реализации ===

Как видно из предыдущих пунктов, масштабируется данный алгоритм хорошо. С увеличением количества процессоров время работы падает, а с увеличением количества входных данных и количества кластеров - растёт. На рисунках показана масштабируемость алгоритма.
[[File:FCMCOMP1.jpg|thumb|center|1500px|Рисунок 2. Масштабируемость алгоритма. Зависимость сложности алгоритма от количества процессоров и входных данных при фиксированном количестве кластеров.]]
[[File:FCMCOMP2.jpg|thumb|center|1500px|Рисунок 3. Масштабируемость алгоритма. Зависимость сложности алгоритма от количества процессоров и кластеров при фиксированном количестве входных данных.]]

=== Динамические характеристики и эффективность реализации алгоритма ===

=== Выводы для классов архитектур ===

=== Существующие реализации алгоритма ===

Существует множество реализаций данного алгоритма. Рассмотрим некоторые из них:

- Например, тут: https://habrahabr.ru/post/208496/
<ref>Нестер А. "Алгоритм нечёткой кластеризации fuzzy c-means на PHP". [html](https://habrahabr.ru/post/208496/)</ref>
приведено краткое описание алгоритма и приведена его реализация на php. В данной статье довольно подробно расписан каждый шаг алгоритма и приведён соответствующий ему фрагмент кода.

- Тут: http://num-meth.srcc.msu.ru/zhurnal/tom_2012/v13r207.html
<ref>Миниахметов Р.М., Цымблер М.Л. "Интеграция алгоритма кластеризации Fuzzy c-Means в PostgreSQL". [html](http://num-meth.srcc.msu.ru/zhurnal/tom_2012/v13r207.html)</ref>
приводится реализация алгоритма для PostgreSQL, а также прилагается скрипт внедрения алгоритма.

== Литература ==

<references \>

Участник:Demon smd/Нечеткий алгоритм С средних

2016-10-28T09:04:56Z

Marina abramenkova: /* Входные данные алгоритма */

{{algorithm
| name = Нечеткий алгоритм C средних (Fuzzy C-means)
| serial_complexity = <math>O(C^2*N*D*IterNumber)</math>
| pf_height = <math>O(\log_{2}C^4*|X|^3) * IterNumber</math>
| pf_width = <math>O(C^2*|X|)</math>
| input_data = <math>|X|*C </math>
| output_data = <math>|X|*C </math>
}}

Авторы описания алгоритма: [[Участник:Demon smd|Д.А.Гуськов]] [[Участник:marina abramenkova|М.А.Абраменкова]]

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===
Нечёткий алгоритм кластеризации С-средних был разработан (для случая m=2) J.C. Dunn в 1973 г.
<ref>Dunn, J. C. (1973-01-01). "A Fuzzy Relative of the ISODATA Process and Its Use in Detecting Compact Well-Separated Clusters". Journal of Cybernetics. 3 (3): 32–57. doi:10.1080/01969727308546046. ISSN 0022-0280.</ref>
и усовершенствован (для случая m>1)
J.C. Bezdek в 1981 г. <ref>Bezdek, James C. (1981). Pattern Recognition with Fuzzy Objective Function Algorithms. ISBN 0-306-40671-3.</ref>
. В отличие от алгоритма c-means данный метод кластеризации предполагает, что входные данные могут принадлежать более, чем одному кластеру одновременно.
Алгоритм получает на вход набор кластеризуемых векторов, количество кластеров, коэффициент неопределённости m и коэффициент <math>\varepsilon > 0</math>, определяющий точность алгоритма. На выходе алгоритма получаем матрицу вероятностей принадлежности каждого входного вектора каждому кластеру.

Нечеткий алгоритм С средних заключается в следующем. Изначально для каждого вектора определяется случайным образом вероятность принадлежности вектора к каждому кластеру. Далее запускается итерационный процесс, на каждой итерации которого происходит:

1) расчёт центров кластеров

2) расчёт Евклидова расстояния от каждого вектора до центра каждого кластера

3) расчёт и нормализация коэффициентов принадлежности векторов кластерам

4) расчёт значения решающей функции и сравнение этого значения со значением решающей функции на предшествующей итерации: если разница этих значений меньше установленного значения, то алгоритм прекращает работу (решающая функция возвращает сумму всех Евклидовых расстояний каждого объекта к каждому центру кластера умноженному на коэффициент принадлежности)

=== Математическое описание алгоритма ===
Нечеткий алгоритм С средних минимизирует величину:
:<math>
\begin{align}
J_{m} = \sum_{i = 1}^{N}\sum_{j = 1}^{C}u_{i,j}^m\left\Vert{x_{i}-c_{j}}\right\|^2 & , & & 1 \le m \le \infty , \\
\end{align}
</math>
где m - это действительное число не меньше единицы, <math>u_{i,j}</math> - коэффициент принадлежности вектора <math>x_{i}</math> к кластеру <math>c_{j}</math>, <math>x_{i}</math> - <math>i</math>-ый компонент <math>N</math>-мерного вектора <math>x</math>, <math>c_{j}</math>
- центр <math>j</math>-ого кластера, а <math>\left\Vert{*}\right\|</math> - это любая норма, определяющая расстояние от вектора до центра кластера.
Нечёткое разбиение входных данных на кластеры производится итеративной оптимизацией вышеуказанной функции с обновлением коэффициента принадлежности <math>u_{i,j}</math> и переопределением центра кластера <math>c_{j}</math> на каждой итерации алгоритма.

==== Вычисляемые данные на каждой итерации ====
* Центры кластеров рассчитываются по следующей формуле: <math>c_{j} = {{\sum_{i = 1}^{n}{u_{i,j}^m} * x_{i}} \over {\sum_{i = 1}^{n}{u_{i,j}^m}}}</math>, где <math>u_{i,j}</math> — коэффициент принадлежности <math>x_{i}</math> вектора к кластеру <math>c_{j}</math>.

* Коэффициент принадлежности рассчитывается по формуле: <math>u_{i,j} = {1 \over \sum_{k = 1}^{C}{({\left\Vert{x_{i}-c_{j}}\right\| \over \left\Vert{x_{i}-c_{k}}\right\|})}^{2 \over m-1}}</math>

* Решающая функция рассчитывается по формуле: <math>\max_{i,j}(|u_{i,j}^{(k)} - u_{i,j}^{(k-1)}|)</math>, где <math>k</math> - номер итерации алгоритма

=== Вычислительное ядро алгоритма ===

Ядром алгоритма является:
* вычисление новых центров кластеров
* для каждого входного вектора вычисление Евклидова расстояния до центров кластеров, а также коэффициента принадлежности кластерам
* вычисление решающей функции

=== Макроструктура алгоритма ===

В каждой итерации алгоритма происходит 3 основных действия описанных в п. 1.2.1:
*вычисление центров кластеров
*вычисление коэффициентов принадлежности
*вычисление решающей функции
Подробное описание макроструктур в виде кода приведено в пункте 1.5

=== Схема реализации последовательного алгоритма ===

Схему реализации последовательного алгоритма можно описать на C++ следующим образом:

<source lang="C++">

FCM (X[], C, m, eps){
float deside = 0;
float newDeside = 0;
generateMembershipDegree(); //заполняет uPrev[][] случайными нормрованными коэффициентами
while (true){
newDeside = deside;

//вычисление центров кластеров
for (int j=0; j<C; j++){ //для каждого кластера
float numerator = 0;
float denumerator = 0;
for (int i=0; i<X.size(); i++){ //для каждого вектора
numerator+=pow(u[i][j], m) * x[i];
denumerator+=pow(u[i][j], m);
}
c[j] = numerator / denumerator;
}

//вычисление коэффициентов u[][]
for (int i=0; i<X.size(); i++) //для каждого вектора
for (int j=0; j<C; j++){ //для каждого кластера
sum = 0;
for (int k=0; k<C; k++)
sum+= pow( dist(x[i], c[j]) / dist(x[i], c[k]), 2/(m-1));
u[i][j] = 1/sum
}

//определения максимального различия между u[][] и uPrev[][]
float max = 0;
for (int i=0; i<X.size(); i++) //для каждого вектора
for (int j=0; j<C; j++){ //для каждого кластера
if (abs(uPrev[i][j]-u[i][j])>max)
max = abs(uPrev[i][j]-u[i][j]);

if (eps <= max)
for (int i=0; i<X.size(); i++) //для каждого вектора
for (int j=0; j<C; j++){ //для каждого кластера
uPrev[i][j]=u[i][j];
else
break;

}
return u;
}
</source>

=== Последовательная сложность алгоритма ===

Последовательная сложность всего алгоритма складывается из сложности операций на каждой итерации умноженную на количество итераций. Так как в данном алгоритме количество итераций не является фиксированным и зависит от:
* параметра <math>\varepsilon</math>
* набора входных векторов <math>x</math>
* выбора начальных коэффициентов <math>u</math>
то в данном пункте будет приведена сложность одной итерации относительно количества входных векторов.
Как видно из предыдущего пункта, для вычисления центров кластеров требуется <math>O(2*C*|X|)</math> операций, для определения коэффициентов <math>u</math> - <math>O(C^2*|X|)</math> операций, а для вычисления решающей функции - <math>O(2*C*|X|)</math> операций, где <math>|X|</math> - число входных векторов, а <math>C</math> - количество кластеров.

Таким образом итоговая сложность одной итерации составляет <math>O(C^2*|X|)</math>.

=== Информационный граф ===

Как видно из пункта 1.5, на каждом действии каждой итерации алгоритма все операции, выполняющиеся в цикле, не зависят друг от друга и могут быть распаралелены. Это показано на Рисунке 1.

[[File:FCMIG.png|thumb|center|1200px|Рисунок 1. Информационный граф алгоритма. (1)-(7) - это наборы последовательных действий (например, (2) - последовательные операции деления, взятия адреса и присваивания).]]

=== Ресурс параллелизма алгоритма ===

На каждом ярусе ярусно-параллельной формы алгоритма будет располагаться конечное число элементарных операций, например, взятие адреса, сложение или возведение в степень. Информационый граф из п.1.7 изображает свёрнутую ярусно-параллельную форму алгоритма.

Сложность алгоритма будем рассчитывать в предположении, что число вычислительных ядер стремится к бесконечности. Как видно из информационного графа, параллельная сложность вычисления центров кластеров составляет <math>O(\log_{2} C*|X|)</math>, вычисления коэффициентов принадлежности - <math>O(\log_{2} C^2*|X|)</math>, а вычисления решающей функции - не больше чем <math>O(\log_{2} C*|X|)</math>.

Таким образом параллельная сложность итерации алгоритма составляет <math>O(\log_{2} C^4*|X|^3)</math>.

Так как задачи, решаемые в макроструктуре алгоритма могут быть сведены к задачам вычисления суммы элементов массива и максимального элемента массива, то на <math>i</math>-ом ярусе графа будет находиться <math>{N}\over{2^i}</math> операции, где N - количество элементов массива.

=== Входные и выходные данные алгоритма ===

==== Входные данные алгоритма ====
* <math>x_{i}</math> - набор из <math>k</math> входных векторов длины <math>p</math>
* <math>C</math> - количество кластеров
* <math>m</math> - коэффициент неопределённости
* <math>\varepsilon > 0</math> - коэффициент, определяющий точность алгоритма.

Объем входных данных: <math>kp</math> (не считая трех коэффициентов)

==== Выходные данные алгоритма ====
* <math>u</math> - матрица принадлежности векторов кластерам

=== Свойства алгоритма ===

Увеличение скорости работы алгоритма при распараллеливании на бесконечном количестве процессоров составляет <math>O({{C^2*|X|}\over{\log_{2} (C^4*|X|^3)}})</math>. Например, для разбиения 1000 элементов на 10 кластеров производительность параллельного алгоритма будет в 2315 раз больше, а на 20 кластеров - уже в 8477 раз.

== Программная реализация алгоритма ==

=== Особенности реализации последовательного алгоритма ===

=== Локальность данных и вычислений ===

=== Возможные способы и особенности параллельной реализации алгоритма ===

=== Масштабируемость алгоритма и его реализации ===

Как видно из предыдущих пунктов, масштабируется данный алгоритм хорошо. С увеличением количества процессоров время работы падает, а с увеличением количества входных данных и количества кластеров - растёт. На рисунках показана масштабируемость алгоритма.
[[File:FCMCOMP1.jpg|thumb|center|1500px|Рисунок 2. Масштабируемость алгоритма. Зависимость сложности алгоритма от количества процессоров и входных данных при фиксированном количестве кластеров.]]
[[File:FCMCOMP2.jpg|thumb|center|1500px|Рисунок 3. Масштабируемость алгоритма. Зависимость сложности алгоритма от количества процессоров и кластеров при фиксированном количестве входных данных.]]

=== Динамические характеристики и эффективность реализации алгоритма ===

=== Выводы для классов архитектур ===

=== Существующие реализации алгоритма ===

Существует множество реализаций данного алгоритма. Рассмотрим некоторые из них:

- Например, тут: https://habrahabr.ru/post/208496/
<ref>Нестер А. "Алгоритм нечёткой кластеризации fuzzy c-means на PHP". [html](https://habrahabr.ru/post/208496/)</ref>
приведено краткое описание алгоритма и приведена его реализация на php. В данной статье довольно подробно расписан каждый шаг алгоритма и приведён соответствующий ему фрагмент кода.

- Тут: http://num-meth.srcc.msu.ru/zhurnal/tom_2012/v13r207.html
<ref>Миниахметов Р.М., Цымблер М.Л. "Интеграция алгоритма кластеризации Fuzzy c-Means в PostgreSQL". [html](http://num-meth.srcc.msu.ru/zhurnal/tom_2012/v13r207.html)</ref>
приводится реализация алгоритма для PostgreSQL, а также прилагается скрипт внедрения алгоритма.

== Литература ==

<references \>

Участник:Demon smd/Нечеткий алгоритм С средних

2016-10-14T17:47:59Z

Marina abramenkova:

{{Assignment}}

{{algorithm
| name = Нечеткий алгоритм C средних (Fuzzy C-means)
| serial_complexity = <math>O(C^2*N*D*IterNumber)</math>
| pf_height = <math>O(\log_{2}C^4*|X|^3) * IterNumber</math>
| pf_width = <math>O(C^2*|X|)</math>
| input_data = <math>|X|*C </math>
| output_data = <math>|X|*C </math>
}}

Авторы описания алгоритма: [[Участник:Demon smd|Д.А.Гуськов]] [[Участник:marina abramenkova|М.А.Абраменкова]]

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===
Нечёткий алгоритм кластеризации С-средних был разработан (для случая m=2) J.C. Dunn в 1973 г.
<ref>Dunn, J. C. (1973-01-01). "A Fuzzy Relative of the ISODATA Process and Its Use in Detecting Compact Well-Separated Clusters". Journal of Cybernetics. 3 (3): 32–57. doi:10.1080/01969727308546046. ISSN 0022-0280.</ref>
и усовершенствован (для случая m>1)
J.C. Bezdek в 1981 г. <ref>Bezdek, James C. (1981). Pattern Recognition with Fuzzy Objective Function Algorithms. ISBN 0-306-40671-3.</ref>
. В отличие от алгоритма c-means данный метод кластеризации предполагает, что входные данные могут принадлежать более, чем одному кластеру одновременно.
Алгоритм получает на вход набор кластеризуемых векторов, количество кластеров, коэффициент неопределённости m и коэффициент <math>\varepsilon > 0</math>, определяющий точность алгоритма. На выходе алгоритма получаем матрицу вероятностей принадлежности каждого входного вектора каждому кластеру.

Нечеткий алгоритм С средних заключается в следующем. Изначально для каждого вектора определяется случайным образом вероятность принадлежности вектора к каждому кластеру. Далее запускается итерационный процесс, на каждой итерации которого происходит:

1) расчёт центров кластеров

2) расчёт Евклидова расстояния от каждого вектора до центра каждого кластера

3) расчёт и нормализация коэффициентов принадлежности векторов кластерам

4) расчёт значения решающей функции и сравнение этого значения со значением решающей функции на предшествующей итерации: если разница этих значений меньше установленного значения, то алгоритм прекращает работу (решающая функция возвращает сумму всех Евклидовых расстояний каждого объекта к каждому центру кластера умноженному на коэффициент принадлежности)

=== Математическое описание алгоритма ===
Нечеткий алгоритм С средних минимизирует величину:
:<math>
\begin{align}
J_{m} = \sum_{i = 1}^{N}\sum_{j = 1}^{C}u_{i,j}^m\left\Vert{x_{i}-c_{j}}\right\|^2 & , & & 1 \le m \le \infty , \\
\end{align}
</math>
где m - это действительное число не меньше единицы, <math>u_{i,j}</math> - коэффициент принадлежности вектора <math>x_{i}</math> к кластеру <math>c_{j}</math>, <math>x_{i}</math> - <math>i</math>-ый компонент <math>N</math>-мерного вектора <math>x</math>, <math>c_{j}</math>
- центр <math>j</math>-ого кластера, а <math>\left\Vert{*}\right\|</math> - это любая норма, определяющая расстояние от вектора до центра кластера.
Нечёткое разбиение входных данных на кластеры производится итеративной оптимизацией вышеуказанной функции с обновлением коэффициента принадлежности <math>u_{i,j}</math> и переопределением центра кластера <math>c_{j}</math> на каждой итерации алгоритма.

==== Вычисляемые данные на каждой итерации ====
* Центры кластеров рассчитываются по следующей формуле: <math>c_{j} = {{\sum_{i = 1}^{n}{u_{i,j}^m} * x_{i}} \over {\sum_{i = 1}^{n}{u_{i,j}^m}}}</math>, где <math>u_{i,j}</math> — коэффициент принадлежности <math>x_{i}</math> вектора к кластеру <math>c_{j}</math>.

* Коэффициент принадлежности рассчитывается по формуле: <math>u_{i,j} = {1 \over \sum_{k = 1}^{C}{({\left\Vert{x_{i}-c_{j}}\right\| \over \left\Vert{x_{i}-c_{k}}\right\|})}^{2 \over m-1}}</math>

* Решающая функция рассчитывается по формуле: <math>\max_{i,j}(|u_{i,j}^{(k)} - u_{i,j}^{(k-1)}|)</math>, где <math>k</math> - номер итерации алгоритма

=== Вычислительное ядро алгоритма ===

Ядром алгоритма является:
* вычисление новых центров кластеров
* для каждого входного вектора вычисление Евклидова расстояния до центров кластеров, а также коэффициента принадлежности кластерам
* вычисление решающей функции

=== Макроструктура алгоритма ===

В каждой итерации алгоритма происходит 3 основных действия описанных в п. 1.2.1:
*вычисление центров кластеров
*вычисление коэффициентов принадлежности
*вычисление решающей функции
Подробное описание макроструктур в виде кода приведено в пункте 1.5

=== Схема реализации последовательного алгоритма ===

Схему реализации последовательного алгоритма можно описать на C++ следующим образом:

<source lang="C++">

FCM (X[], C, m, eps){
float deside = 0;
float newDeside = 0;
generateMembershipDegree(); //заполняет uPrev[][] случайными нормрованными коэффициентами
while (true){
newDeside = deside;

//вычисление центров кластеров
for (int j=0; j<C; j++){ //для каждого кластера
float numerator = 0;
float denumerator = 0;
for (int i=0; i<X.size(); i++){ //для каждого вектора
numerator+=pow(u[i][j], m) * x[i];
denumerator+=pow(u[i][j], m);
}
c[j] = numerator / denumerator;
}

//вычисление коэффициентов u[][]
for (int i=0; i<X.size(); i++) //для каждого вектора
for (int j=0; j<C; j++){ //для каждого кластера
sum = 0;
for (int k=0; k<C; k++)
sum+= pow( dist(x[i], c[j]) / dist(x[i], c[k]), 2/(m-1));
u[i][j] = 1/sum
}

//определения максимального различия между u[][] и uPrev[][]
float max = 0;
for (int i=0; i<X.size(); i++) //для каждого вектора
for (int j=0; j<C; j++){ //для каждого кластера
if (abs(uPrev[i][j]-u[i][j])>max)
max = abs(uPrev[i][j]-u[i][j]);

if (eps <= max)
for (int i=0; i<X.size(); i++) //для каждого вектора
for (int j=0; j<C; j++){ //для каждого кластера
uPrev[i][j]=u[i][j];
else
break;

}
return u;
}
</source>

=== Последовательная сложность алгоритма ===

Последовательная сложность всего алгоритма складывается из сложности операций на каждой итерации умноженную на количество итераций. Так как в данном алгоритме количество итераций не является фиксированным и зависит от:
* параметра <math>\varepsilon</math>
* набора входных векторов <math>x</math>
* выбора начальных коэффициентов <math>u</math>
то в данном пункте будет приведена сложность одной итерации относительно количества входных векторов.
Как видно из предыдущего пункта, для вычисления центров кластеров требуется <math>O(2*C*|X|)</math> операций, для определения коэффициентов <math>u</math> - <math>O(C^2*|X|)</math> операций, а для вычисления решающей функции - <math>O(2*C*|X|)</math> операций, где <math>|X|</math> - число входных векторов, а <math>C</math> - количество кластеров.

Таким образом итоговая сложность одной итерации составляет <math>O(C^2*|X|)</math>.

=== Информационный граф ===

Как видно из пункта 1.5, на каждом действии каждой итерации алгоритма все операции, выполняющиеся в цикле, не зависят друг от друга и могут быть распаралелены. Это показано на Рисунке 1.

[[File:FCMIG.png|thumb|center|1200px|Рисунок 1. Информационный граф алгоритма. (1)-(7) - это наборы последовательных действий (например, (2) - последовательные операции деления, взятия адреса и присваивания).]]

=== Ресурс параллелизма алгоритма ===

На каждом ярусе ярусно-параллельной формы алгоритма будет располагаться конечное число элементарных операций, например, взятие адреса, сложение или возведение в степень. Информационый граф из п.1.7 изображает свёрнутую ярусно-параллельную форму алгоритма.

Сложность алгоритма будем рассчитывать в предположении, что число вычислительных ядер стремится к бесконечности. Как видно из информационного графа, параллельная сложность вычисления центров кластеров составляет <math>O(\log_{2} C*|X|)</math>, вычисления коэффициентов принадлежности - <math>O(\log_{2} C^2*|X|)</math>, а вычисления решающей функции - не больше чем <math>O(\log_{2} C*|X|)</math>.

Таким образом параллельная сложность итерации алгоритма составляет <math>O(\log_{2} C^4*|X|^3)</math>.

Так как задачи, решаемые в макроструктуре алгоритма могут быть сведены к задачам вычисления суммы элементов массива и максимального элемента массива, то на <math>i</math>-ом ярусе графа будет находиться <math>{N}\over{2^i}</math> операции, где N - количество элементов массива.

=== Входные и выходные данные алгоритма ===

==== Входные данные алгоритма ====
* <math>x_{i}</math> - набор входных векторов
* <math>C</math> - количество кластеров
* <math>m</math> - коэффициент неопределённости
* <math>\varepsilon > 0</math> - коэффициент, определяющий точность алгоритма.

==== Выходные данные алгоритма ====
* <math>u</math> - матрица принадлежности векторов кластерам

=== Свойства алгоритма ===

Увеличение скорости работы алгоритма при распараллеливании на бесконечном количестве процессоров составляет <math>O({{C^2*|X|}\over{\log_{2} (C^4*|X|^3)}})</math>. Например, для разбиения 1000 элементов на 10 кластеров производительность параллельного алгоритма будет в 2315 раз больше, а на 20 кластеров - уже в 8477 раз.

== Программная реализация алгоритма ==

=== Особенности реализации последовательного алгоритма ===

=== Локальность данных и вычислений ===

=== Возможные способы и особенности параллельной реализации алгоритма ===

=== Масштабируемость алгоритма и его реализации ===

Как видно из предыдущих пунктов, масштабируется данный алгоритм хорошо. С увеличением количества процессоров время работы падает, а с увеличением количества входных данных и количества кластеров - растёт. На рисунках показана масштабируемость алгоритма.
[[File:FCMCOMP1.jpg|thumb|center|1500px|Рисунок 2. Масштабируемость алгоритма. Зависимость сложности алгоритма от количества процессоров и входных данных при фиксированном количестве кластеров.]]
[[File:FCMCOMP2.jpg|thumb|center|1500px|Рисунок 3. Масштабируемость алгоритма. Зависимость сложности алгоритма от количества процессоров и кластеров при фиксированном количестве входных данных.]]

=== Динамические характеристики и эффективность реализации алгоритма ===

=== Выводы для классов архитектур ===

=== Существующие реализации алгоритма ===

Существует множество реализаций данного алгоритма. Рассмотрим некоторые из них:

- Например, тут: https://habrahabr.ru/post/208496/
<ref>Нестер А. "Алгоритм нечёткой кластеризации fuzzy c-means на PHP". [html](https://habrahabr.ru/post/208496/)</ref>
приведено краткое описание алгоритма и приведена его реализация на php. В данной статье довольно подробно расписан каждый шаг алгоритма и приведён соответствующий ему фрагмент кода.

- Тут: http://num-meth.srcc.msu.ru/zhurnal/tom_2012/v13r207.html
<ref>Миниахметов Р.М., Цымблер М.Л. "Интеграция алгоритма кластеризации Fuzzy c-Means в PostgreSQL". [html](http://num-meth.srcc.msu.ru/zhurnal/tom_2012/v13r207.html)</ref>
приводится реализация алгоритма для PostgreSQL, а также прилагается скрипт внедрения алгоритма.

== Литература ==

<references \>

Обсуждение участника:Lineprinter

2016-10-14T17:42:37Z

Marina abramenkova:

== Перенос ==
Статья: [[Алгоритм кластеризации, основанный на сетях Кохоннена]];
Выполняют: Логвиненко Александра и Адиев Тохтар

Статья: [[Ортогонализация Грама-Шмидта]];
Выполняют: [[Участник:KibAndrey| Кибанов Андрей]] и Аджиева Татьяна

Статья: [[Самоорганизующиеся карты Кохонена]];
Выполняет: [[Участник:Anton goy| Гой Антон]]

Статья:[[ЕМ-алгоритм_(Тематическое_моделирование)]];
Выполняют: Мурат Апишев и Андрей Заночкин

Статья:[[Алгоритм_Ланцоша_с_полной_переортогонализацией]];
Выполняет:[[Участник:Sfedotov| Федотов С.А.]]

Статья: [[Алгоритм_k-средних]]
Выполняют: [[Участник:Error2407|Богомазов Евгений]], [[Участник:Илья_Егоров|Егоров Илья]]

Статья: [[Нечеткий_алгоритм_С_средних]]
Выполняют: [[Участник:Demon smd|Д.А.Гуськов]], [[Участник:marina abramenkova|М.А.Абраменкова]]

Статья: [[Решение_задачи_Коши_для_системы_ОДУ_методом_Рунге-Кутты_4_порядка]];
Выполняют: [[Участник:Алимов_Дамир_Алиевич|Алимов Дамир]] и [[Участник:Anlesnichiy|Антон Лесничий]]

Статья: [[Строгий_алгоритм_С_средних_(Hard_C-Means,_HCM)]];
Выполняют: [[Участник:Светлана_Лукьяненко|Лукьяненко Светлана]] и [[Участник:Юрий_Комаров|Комаров Юрий]]

Статья: [[Алгоритм кластеризации, основанный на минимальном остовном дереве]];
Выполняет: [[Участник:Astandrik | Стандрик Антон Сергеевич]]

Статья: [[Нахождение_собственных_чисел_квадратной_матрицы_методом_QR_разложения_(3)|Нахождение собственных чисел квадратной матрицы методом QR разложения (3)]];
Выполняют: [[Участник:Смирнова_Александра|Смирнова А.С.]], [[Участник:Александра_Киямова|Киямова А.]]

Статья: [[Метод_Якоби_вычисления_сингулярных_чисел_и_векторов]];
Выполняют: [[Участница:Почернина_Елена| Почернина Елена]] и [[Участница:Светлана|Костюкова Светлана]]

Статья: [[Метод_Ньютона_для_решения_систем_нелинейных_уравнений(2)]];
Выполняют: [[Участник:Oleggium|Гирняк О.Р.]], [[Участник:Dimx19|Васильков Д.А.]]

Статья: [[Алгоритм_кластеризации_с_использованием_представлений]];
Выполняют: [[Участник:Cookie|Шатков С.А.]], [[Антохина Ю.А.]]

Статья: [[Быстрое_преобразование_Фурье_(FFT)|Быстрое преобразование Фурье (FFT)]];
Выполняют: [[Участник:Victoria_Stepanischeva|Степанищева Виктория]] и [[Участник:Igor_Munkin|Мунькин Игорь]]

Статья: [[Быстрое_дискретное_преобразование_Фурье|Быстрое_дискретное_преобразование_Фурье]];
Выполняют: [[Участник:ivanov.kir.m | К.М.Иванов]], [[Участник:Pumpkin | А.C.Сапин]]

Статья:[[Алгоритм_k_средних]]
Выполняют: [[Участник:Parkhomenko|Пархоменко Павел]], [[Участник:ivan.mashonskiy|Машонский Иван]]

Статья:[[EM-алгоритм_кластеризации]]
Выполняет: [[Участник:Noite|Зинченко Дмитрий]]

Статья:[[Алгоритм_k_means]]
Выполняют: [[Участник:IanaV| Валуйская Яна]], [[Глотов Евгений]]

Статья: [[Метод Якоби вычисления собственных значений симметричной матрицы ЗП |Метод Якоби вычисления собственных значений симметричной матрицы ЗП]];
Выполняют: [[Участник:Зиновьев Владимир|Зиновьев В.С.]], [[Участник:Пронин Андрей|Пронин А.М.]]

Статья:[[Алгоритм_кластеризации,_основанный_на_минимальном_покрывающем_дереве]]
Выполняет: [[Участник:Kanast74|Дмитриева Анастасия]]

Статья:[[Нахождение_собственных_чисел_квадратной_матрицы_методом_QR_разложения_(4)]]
Выполняют: [[Участник:F-morozov|Морозов Ф. В.]], [[Участник:Nataliya|Пащенко Н. Ф.]]

Статья:[[Хранение_ненулевых_элементов_разреженных_матриц._Умножение_разреженной_матрицы_на_вектор]];
Выполняют: [[Участник:Trrufina|Третьякова Р.М.]] и [[Участник:Екатерина_Буторина|Буторина Е.В.]]

Статья: [[Алгоритм_кластеризации_с_использованием_представлений2]];
Выполняет: [[Участник:Лукьянова Анна|Лукьянова А.Я.]]

Статья: [[Метод Якоби вычисления собственных значений симметричной матрицы]];
Выполняют: [[Участник: Galkina|Галкина А.С.]], [[Участник: Игорь|Плахов И.А.]]

Статья: [[Метод рекурсивной координатной бисекции]];
Выполняют: [[Участник: Obirvalger|Гордеев Михаил]], [[Участник: KolmakovEA|Колмаков Евгений]]

Статья: [[Итерационный метод решения системы линейных алгебраических уравнений GMRES (обобщенный метод минимальных невязок)]];
Выполняют: [[Участник: Эльвира Ахиярова|Ахиярова Эльвира]]

Статья: [[Хранение ненулевых элементов разреженной матрицы. Умножение разреженной матрицы на вектор]];
Выполняют: [[Участник: Janyell|Сычева Евгения]], [[Участник: Ahahalin|Хахалин Анатолий]]

Статья: [[Построение матрицы Адамара произвольного размера]];
Выполняют: [[Участник: Бугаков Юрий|Бугаков Юрий]], Кужамалиев Ернур

Статья: [[Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки (1)]]
Выполняют: [[Участница:Sannikovats| Санникова Татьяна Сергеевна]], [[Участник:Plukshin| Лукшин Петр Андреевич]]

Статья: [[Алгоритм кластеризации, основанный на построении каркаса]];
Выполняют: [[Участник:SenderovichNikita| Сендерович Никита]]

Статья: [[Алгоритм кластеризации, основанный на максимизации ожидания]];
Выполняют: Готман Мария, Лукашкина Юлия

Участник:Demon smd/Нечеткий алгоритм С средних

2016-10-14T17:31:39Z

Marina abramenkova:

{{algorithm
| name = Нечеткий алгоритм C средних (Fuzzy C-means)
| serial_complexity = <math>O(C^2*N*D*IterNumber)</math>
| pf_height = <math>O(\log_{2}C^4*|X|^3) * IterNumber</math>
| pf_width = <math>O(C^2*|X|)</math>
| input_data = <math>|X|*C </math>
| output_data = <math>|X|*C </math>
}}

Авторы описания алгоритма: [[Участник:Demon smd|Д.А.Гуськов]] [[Участник:marina abramenkova|М.А.Абраменкова]]

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===
Нечёткий алгоритм кластеризации С-средних был разработан (для случая m=2) J.C. Dunn в 1973 г.
<ref>Dunn, J. C. (1973-01-01). "A Fuzzy Relative of the ISODATA Process and Its Use in Detecting Compact Well-Separated Clusters". Journal of Cybernetics. 3 (3): 32–57. doi:10.1080/01969727308546046. ISSN 0022-0280.</ref>
и усовершенствован (для случая m>1)
J.C. Bezdek в 1981 г. <ref>Bezdek, James C. (1981). Pattern Recognition with Fuzzy Objective Function Algorithms. ISBN 0-306-40671-3.</ref>
. В отличие от алгоритма c-means данный метод кластеризации предполагает, что входные данные могут принадлежать более, чем одному кластеру одновременно.
Алгоритм получает на вход набор кластеризуемых векторов, количество кластеров, коэффициент неопределённости m и коэффициент <math>\varepsilon > 0</math>, определяющий точность алгоритма. На выходе алгоритма получаем матрицу вероятностей принадлежности каждого входного вектора каждому кластеру.

Нечеткий алгоритм С средних заключается в следующем. Изначально для каждого вектора определяется случайным образом вероятность принадлежности вектора к каждому кластеру. Далее запускается итерационный процесс, на каждой итерации которого происходит:

1) расчёт центров кластеров

2) расчёт Евклидова расстояния от каждого вектора до центра каждого кластера

3) расчёт и нормализация коэффициентов принадлежности векторов кластерам

4) расчёт значения решающей функции и сравнение этого значения со значением решающей функции на предшествующей итерации: если разница этих значений меньше установленного значения, то алгоритм прекращает работу (решающая функция возвращает сумму всех Евклидовых расстояний каждого объекта к каждому центру кластера умноженному на коэффициент принадлежности)

=== Математическое описание алгоритма ===
Нечеткий алгоритм С средних минимизирует величину:
:<math>
\begin{align}
J_{m} = \sum_{i = 1}^{N}\sum_{j = 1}^{C}u_{i,j}^m\left\Vert{x_{i}-c_{j}}\right\|^2 & , & & 1 \le m \le \infty , \\
\end{align}
</math>
где m - это действительное число не меньше единицы, <math>u_{i,j}</math> - коэффициент принадлежности вектора <math>x_{i}</math> к кластеру <math>c_{j}</math>, <math>x_{i}</math> - <math>i</math>-ый компонент <math>N</math>-мерного вектора <math>x</math>, <math>c_{j}</math>
- центр <math>j</math>-ого кластера, а <math>\left\Vert{*}\right\|</math> - это любая норма, определяющая расстояние от вектора до центра кластера.
Нечёткое разбиение входных данных на кластеры производится итеративной оптимизацией вышеуказанной функции с обновлением коэффициента принадлежности <math>u_{i,j}</math> и переопределением центра кластера <math>c_{j}</math> на каждой итерации алгоритма.

==== Вычисляемые данные на каждой итерации ====
* Центры кластеров рассчитываются по следующей формуле: <math>c_{j} = {{\sum_{i = 1}^{n}{u_{i,j}^m} * x_{i}} \over {\sum_{i = 1}^{n}{u_{i,j}^m}}}</math>, где <math>u_{i,j}</math> — коэффициент принадлежности <math>x_{i}</math> вектора к кластеру <math>c_{j}</math>.

* Коэффициент принадлежности рассчитывается по формуле: <math>u_{i,j} = {1 \over \sum_{k = 1}^{C}{({\left\Vert{x_{i}-c_{j}}\right\| \over \left\Vert{x_{i}-c_{k}}\right\|})}^{2 \over m-1}}</math>

* Решающая функция рассчитывается по формуле: <math>\max_{i,j}(|u_{i,j}^{(k)} - u_{i,j}^{(k-1)}|)</math>, где <math>k</math> - номер итерации алгоритма

=== Вычислительное ядро алгоритма ===

Ядром алгоритма является:
* вычисление новых центров кластеров
* для каждого входного вектора вычисление Евклидова расстояния до центров кластеров, а также коэффициента принадлежности кластерам
* вычисление решающей функции

=== Макроструктура алгоритма ===

В каждой итерации алгоритма происходит 3 основных действия описанных в п. 1.2.1:
*вычисление центров кластеров
*вычисление коэффициентов принадлежности
*вычисление решающей функции
Подробное описание макроструктур в виде кода приведено в пункте 1.5

=== Схема реализации последовательного алгоритма ===

Схему реализации последовательного алгоритма можно описать на C++ следующим образом:

<source lang="C++">

FCM (X[], C, m, eps){
float deside = 0;
float newDeside = 0;
generateMembershipDegree(); //заполняет uPrev[][] случайными нормрованными коэффициентами
while (true){
newDeside = deside;

//вычисление центров кластеров
for (int j=0; j<C; j++){ //для каждого кластера
float numerator = 0;
float denumerator = 0;
for (int i=0; i<X.size(); i++){ //для каждого вектора
numerator+=pow(u[i][j], m) * x[i];
denumerator+=pow(u[i][j], m);
}
c[j] = numerator / denumerator;
}

//вычисление коэффициентов u[][]
for (int i=0; i<X.size(); i++) //для каждого вектора
for (int j=0; j<C; j++){ //для каждого кластера
sum = 0;
for (int k=0; k<C; k++)
sum+= pow( dist(x[i], c[j]) / dist(x[i], c[k]), 2/(m-1));
u[i][j] = 1/sum
}

//определения максимального различия между u[][] и uPrev[][]
float max = 0;
for (int i=0; i<X.size(); i++) //для каждого вектора
for (int j=0; j<C; j++){ //для каждого кластера
if (abs(uPrev[i][j]-u[i][j])>max)
max = abs(uPrev[i][j]-u[i][j]);

if (eps <= max)
for (int i=0; i<X.size(); i++) //для каждого вектора
for (int j=0; j<C; j++){ //для каждого кластера
uPrev[i][j]=u[i][j];
else
break;

}
return u;
}
</source>

=== Последовательная сложность алгоритма ===

Последовательная сложность всего алгоритма складывается из сложности операций на каждой итерации умноженную на количество итераций. Так как в данном алгоритме количество итераций не является фиксированным и зависит от:
* параметра <math>\varepsilon</math>
* набора входных векторов <math>x</math>
* выбора начальных коэффициентов <math>u</math>
то в данном пункте будет приведена сложность одной итерации относительно количества входных векторов.
Как видно из предыдущего пункта, для вычисления центров кластеров требуется <math>O(2*C*|X|)</math> операций, для определения коэффициентов <math>u</math> - <math>O(C^2*|X|)</math> операций, а для вычисления решающей функции - <math>O(2*C*|X|)</math> операций, где <math>|X|</math> - число входных векторов, а <math>C</math> - количество кластеров.

Таким образом итоговая сложность одной итерации составляет <math>O(C^2*|X|)</math>.

=== Информационный граф ===

Как видно из пункта 1.5, на каждом действии каждой итерации алгоритма все операции, выполняющиеся в цикле, не зависят друг от друга и могут быть распаралелены. Это показано на Рисунке 1.

[[File:FCMIG.png|thumb|center|1200px|Рисунок 1. Информационный граф алгоритма. (1)-(7) - это наборы последовательных действий (например, (2) - последовательные операции деления, взятия адреса и присваивания).]]

=== Ресурс параллелизма алгоритма ===

На каждом ярусе ярусно-параллельной формы алгоритма будет располагаться конечное число элементарных операций, например, взятие адреса, сложение или возведение в степень. Информационый граф из п.1.7 изображает свёрнутую ярусно-параллельную форму алгоритма.

Сложность алгоритма будем рассчитывать в предположении, что число вычислительных ядер стремится к бесконечности. Как видно из информационного графа, параллельная сложность вычисления центров кластеров составляет <math>O(\log_{2} C*|X|)</math>, вычисления коэффициентов принадлежности - <math>O(\log_{2} C^2*|X|)</math>, а вычисления решающей функции - не больше чем <math>O(\log_{2} C*|X|)</math>.

Таким образом параллельная сложность итерации алгоритма составляет <math>O(\log_{2} C^4*|X|^3)</math>.

Так как задачи, решаемые в макроструктуре алгоритма могут быть сведены к задачам вычисления суммы элементов массива и максимального элемента массива, то на <math>i</math>-ом ярусе графа будет находиться <math>{N}\over{2^i}</math> операции, где N - количество элементов массива.

=== Входные и выходные данные алгоритма ===

==== Входные данные алгоритма ====
* <math>x_{i}</math> - набор входных векторов
* <math>C</math> - количество кластеров
* <math>m</math> - коэффициент неопределённости
* <math>\varepsilon > 0</math> - коэффициент, определяющий точность алгоритма.

==== Выходные данные алгоритма ====
* <math>u</math> - матрица принадлежности векторов кластерам

=== Свойства алгоритма ===

Увеличение скорости работы алгоритма при распараллеливании на бесконечном количестве процессоров составляет <math>O({{C^2*|X|}\over{\log_{2} (C^4*|X|^3)}})</math>. Например, для разбиения 1000 элементов на 10 кластеров производительность параллельного алгоритма будет в 2315 раз больше, а на 20 кластеров - уже в 8477 раз.

== Программная реализация алгоритма ==

=== Особенности реализации последовательного алгоритма ===

=== Локальность данных и вычислений ===

=== Возможные способы и особенности параллельной реализации алгоритма ===

=== Масштабируемость алгоритма и его реализации ===

Как видно из предыдущих пунктов, масштабируется данный алгоритм хорошо. С увеличением количества процессоров время работы падает, а с увеличением количества входных данных и количества кластеров - растёт. На рисунках показана масштабируемость алгоритма.
[[File:FCMCOMP1.jpg|thumb|center|1500px|Рисунок 2. Масштабируемость алгоритма. Зависимость сложности алгоритма от количества процессоров и входных данных при фиксированном количестве кластеров.]]
[[File:FCMCOMP2.jpg|thumb|center|1500px|Рисунок 3. Масштабируемость алгоритма. Зависимость сложности алгоритма от количества процессоров и кластеров при фиксированном количестве входных данных.]]

=== Динамические характеристики и эффективность реализации алгоритма ===

=== Выводы для классов архитектур ===

=== Существующие реализации алгоритма ===

Существует множество реализаций данного алгоритма. Рассмотрим некоторые из них:

- Например, тут: https://habrahabr.ru/post/208496/
<ref>Нестер А. "Алгоритм нечёткой кластеризации fuzzy c-means на PHP". [html](https://habrahabr.ru/post/208496/)</ref>
приведено краткое описание алгоритма и приведена его реализация на php. В данной статье довольно подробно расписан каждый шаг алгоритма и приведён соответствующий ему фрагмент кода.

- Тут: http://num-meth.srcc.msu.ru/zhurnal/tom_2012/v13r207.html
<ref>Миниахметов Р.М., Цымблер М.Л. "Интеграция алгоритма кластеризации Fuzzy c-Means в PostgreSQL". [html](http://num-meth.srcc.msu.ru/zhurnal/tom_2012/v13r207.html)</ref>
приводится реализация алгоритма для PostgreSQL, а также прилагается скрипт внедрения алгоритма.

== Литература ==

<references \>

Участник:Demon smd/Нечеткий алгоритм С средних

2016-10-14T17:15:10Z

Marina abramenkova:

{{algorithm
| name = Нечеткий алгоритм C средних (Fuzzy C-means)
| serial_complexity = <math>O(C^2*N*D*IterNumber)</math>
| pf_height = <math>O(\log_{2}C^4*|X|^3) * IterNumber</math>
| pf_width = <math>O(C^2*|X|)</math>
| input_data = <math>|X|*C </math>
| output_data = <math>|X|*C </math>
}}

Авторы описания алгоритма: [[Участник:Demon smd|Д.А.Гуськов]] [[Участник:marina abramenkova|М.А.Абраменкова]]

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===
Нечёткий алгоритм кластеризации С-средних был разработан (для случая m=2) J.C. Dunn в 1973 г.
<ref>Dunn, J. C. (1973-01-01). "A Fuzzy Relative of the ISODATA Process and Its Use in Detecting Compact Well-Separated Clusters". Journal of Cybernetics. 3 (3): 32–57. doi:10.1080/01969727308546046. ISSN 0022-0280.</ref>
и усовершенствован (для случая m>1)
J.C. Bezdek в 1981 г. <ref>Bezdek, James C. (1981). Pattern Recognition with Fuzzy Objective Function Algorithms. ISBN 0-306-40671-3.</ref>
. В отличие от алгоритма c-means данный метод кластеризации предполагает, что входные данные могут принадлежать более, чем одному кластеру одновременно.
Алгоритм получает на вход набор кластеризуемых векторов, количество кластеров, коэффициент неопределённости m и коэффициент <math>\varepsilon > 0</math>, определяющий точность алгоритма. На выходе алгоритма получаем матрицу вероятностей принадлежности каждого входного вектора каждому кластеру.

Нечеткий алгоритм С средних заключается в следующем. Изначально для каждого вектора определяется случайным образом вероятность принадлежности вектора к каждому кластеру. Далее запускается итерационный процесс, на каждой итерации которого происходит:

1) расчёт центров кластеров

2) расчёт Евклидова расстояния от каждого вектора до центра каждого кластера

3) расчёт и нормализация коэффициентов принадлежности векторов кластерам

4) расчёт значения решающей функции и сравнение этого значения со значением решающей функции на предшествующей итерации: если разница этих значений меньше установленного значения, то алгоритм прекращает работу (решающая функция возвращает сумму всех Евклидовых расстояний каждого объекта к каждому центру кластера умноженному на коэффициент принадлежности)

=== Математическое описание алгоритма ===
Нечеткий алгоритм С средних минимизирует величину:
:<math>
\begin{align}
J_{m} = \sum_{i = 1}^{N}\sum_{j = 1}^{C}u_{i,j}^m\left\Vert{x_{i}-c_{j}}\right\|^2 & , & & 1 \le m \le \infty , \\
\end{align}
</math>
где m - это действительное число не меньше единицы, <math>u_{i,j}</math> - коэффициент принадлежности вектора <math>x_{i}</math> к кластеру <math>c_{j}</math>, <math>x_{i}</math> - <math>i</math>-ый компонент <math>N</math>-мерного вектора <math>x</math>, <math>c_{j}</math>
- центр <math>j</math>-ого кластера, а <math>\left\Vert{*}\right\|</math> - это любая норма, определяющая расстояние от вектора до центра кластера.
Нечёткое разбиение входных данных на кластеры производится итеративной оптимизацией вышеуказанной функции с обновлением коэффициента принадлежности <math>u_{i,j}</math> и переопределением центра кластера <math>c_{j}</math> на каждой итерации алгоритма.

==== Вычисляемые данные на каждой итерации ====
* Центры кластеров рассчитываются по следующей формуле: <math>c_{j} = {{\sum_{i = 1}^{n}{u_{i,j}^m} * x_{i}} \over {\sum_{i = 1}^{n}{u_{i,j}^m}}}</math>, где <math>u_{i,j}</math> — коэффициент принадлежности <math>x_{i}</math> вектора к кластеру <math>c_{j}</math>.

* Коэффициент принадлежности рассчитывается по формуле: <math>u_{i,j} = {1 \over \sum_{k = 1}^{C}{({\left\Vert{x_{i}-c_{j}}\right\| \over \left\Vert{x_{i}-c_{k}}\right\|})}^{2 \over m-1}}</math>

* Решающая функция рассчитывается по формуле: <math>\max_{i,j}(|u_{i,j}^{(k)} - u_{i,j}^{(k-1)}|)</math>, где <math>k</math> - номер итерации алгоритма

=== Вычислительное ядро алгоритма ===

Ядром алгоритма является:
* вычисление новых центров кластеров
* для каждого входного вектора вычисление Евклидова расстояния до центров кластеров, а также коэффициента принадлежности кластерам
* вычисление решающей функции

=== Макроструктура алгоритма ===

В каждой итерации алгоритма происходит 3 основных действия описанных в п. 1.2.1:
*вычисление центров кластеров
*вычисление коэффициентов принадлежности
*вычисление решающей функции
Подробное описание макроструктур в виде кода приведено в пункте 1.5

=== Схема реализации последовательного алгоритма ===

Схему реализации последовательного алгоритма можно описать на C++ следующим образом:

<source lang="C++">

FCM (X[], C, m, eps){
float deside = 0;
float newDeside = 0;
generateMembershipDegree(); //заполняет uPrev[][] случайными нормрованными коэффициентами
while (true){
newDeside = deside;

//вычисление центров кластеров
for (int j=0; j<C; j++){ //для каждого кластера
float numerator = 0;
float denumerator = 0;
for (int i=0; i<X.size(); i++){ //для каждого вектора
numerator+=pow(u[i][j], m) * x[i];
denumerator+=pow(u[i][j], m);
}
c[j] = numerator / denumerator;
}

//вычисление коэффициентов u[][]
for (int i=0; i<X.size(); i++) //для каждого вектора
for (int j=0; j<C; j++){ //для каждого кластера
sum = 0;
for (int k=0; k<C; k++)
sum+= pow( dist(x[i], c[j]) / dist(x[i], c[k]), 2/(m-1));
u[i][j] = 1/sum
}

//определения максимального различия между u[][] и uPrev[][]
float max = 0;
for (int i=0; i<X.size(); i++) //для каждого вектора
for (int j=0; j<C; j++){ //для каждого кластера
if (abs(uPrev[i][j]-u[i][j])>max)
max = abs(uPrev[i][j]-u[i][j]);

if (eps <= max)
for (int i=0; i<X.size(); i++) //для каждого вектора
for (int j=0; j<C; j++){ //для каждого кластера
uPrev[i][j]=u[i][j];
else
break;

}
return u;
}
</source>

=== Последовательная сложность алгоритма ===

Последовательная сложность всего алгоритма складывается из сложности операций на каждой итерации умноженную на количество итераций. Так как в данном алгоритме количество итераций не является фиксированным и зависит от:
* параметра <math>\varepsilon</math>
* набора входных векторов <math>x</math>
* выбора начальных коэффициентов <math>u</math>
то в данном пункте будет приведена сложность одной итерации относительно количества входных векторов.
Как видно из предыдущего пункта, для вычисления центров кластеров требуется <math>O(2*C*|X|)</math> операций, для определения коэффициентов <math>u</math> - <math>O(C^2*|X|)</math> операций, а для вычисления решающей функции - <math>O(2*C*|X|)</math> операций, где <math>|X|</math> - число входных векторов, а <math>C</math> - количество кластеров.

Таким образом итоговая сложность одной итерации составляет <math>O(C^2*|X|)</math>.

=== Информационный граф ===

Как видно из пункта 1.5, на каждом действии каждой итерации алгоритма все операции, выполняющиеся в цикле, не зависят друг от друга и могут быть распаралелены. Это показано на Рисунке 1.

[[File:FCMIG.png|thumb|center|1200px|Рисунок 1. Информационный граф алгоритма. (1)-(7) - это наборы последовательных действий (например, (2) - последовательные операции деления, взятия адреса и присваивания).]]

=== Ресурс параллелизма алгоритма ===

На каждом ярусе ярусно-параллельной формы алгоритма будет располагаться конечное число элементарных операций, например, взятие адреса, сложение или возведение в степень. Информационый граф из п.1.7 изображает свёрнутую ярусно-параллельную форму алгоритма.

Сложность алгоритма будем рассчитывать в предположении, что число вычислительных ядер стремится к бесконечности. Как видно из информационного графа, параллельная сложность вычисления центров кластеров составляет <math>O(\log_{2} C*|X|)</math>, вычисления коэффициентов принадлежности - <math>O(\log_{2} C^2*|X|)</math>, а вычисления решающей функции - не больше чем <math>O(\log_{2} C*|X|)</math>.

Таким образом параллельная сложность итерации алгоритма составляет <math>O(\log_{2} C^4*|X|^3)</math>.

Так как задачи, решаемые в макроструктуре алгоритма могут быть сведены к задачам вычисления суммы элементов массива и максимального элемента массива, то на <math>i</math>-ом ярусе графа будет находиться <math>{N}\over{2^i}</math> операции, где N - количество элементов массива.

=== Входные и выходные данные алгоритма ===

==== Входные данные алгоритма ====
* <math>x_{i}</math> - набор входных векторов
* <math>C</math> - количество кластеров
* <math>m</math> - коэффициент неопределённости
* <math>\varepsilon > 0</math> - коэффициент, определяющий точность алгоритма.

==== Выходные данные алгоритма ====
* <math>u</math> - матрица принадлежности векторов кластерам

=== Свойства алгоритма ===

Увеличение скорости работы алгоритма при распараллеливании на бесконечном количестве процессоров составляет <math>O({{C^2*|X|}\over{\log_{2} (C^4*|X|^3)}})</math>. Например, для разбиения 1000 элементов на 10 кластеров производительность параллельного алгоритма будет в 2315 раз больше, а на 20 кластеров - уже в 8477 раз.

== Программная реализация алгоритма ==

=== Масштабируемость алгоритма и его реализации ===

Как видно из предыдущих пунктов, масштабируется данный алгоритм хорошо. С увеличением количества процессоров время работы падает, а с увеличением количества входных данных и количества кластеров - растёт. На рисунках показана масштабируемость алгоритма.
[[File:FCMCOMP1.jpg|thumb|center|1500px|Рисунок 2. Масштабируемость алгоритма. Зависимость сложности алгоритма от количества процессоров и входных данных при фиксированном количестве кластеров.]]
[[File:FCMCOMP2.jpg|thumb|center|1500px|Рисунок 3. Масштабируемость алгоритма. Зависимость сложности алгоритма от количества процессоров и кластеров при фиксированном количестве входных данных.]]

=== Существующие реализации алгоритма ===

Существует множество реализаций данного алгоритма. Рассмотрим некоторые из них:

- Например, тут: https://habrahabr.ru/post/208496/
<ref>Нестер А. "Алгоритм нечёткой кластеризации fuzzy c-means на PHP". [html](https://habrahabr.ru/post/208496/)</ref>
приведено краткое описание алгоритма и приведена его реализация на php. В данной статье довольно подробно расписан каждый шаг алгоритма и приведён соответствующий ему фрагмент кода.

- Тут: http://num-meth.srcc.msu.ru/zhurnal/tom_2012/v13r207.html
<ref>Миниахметов Р.М., Цымблер М.Л. "Интеграция алгоритма кластеризации Fuzzy c-Means в PostgreSQL". [html](http://num-meth.srcc.msu.ru/zhurnal/tom_2012/v13r207.html)</ref>
приводится реализация алгоритма для PostgreSQL, а также прилагается скрипт внедрения алгоритма.

== Литература ==

<references \>

Участник:Demon smd/Нечеткий алгоритм С средних

2016-10-02T11:35:59Z

Marina abramenkova: /* Информационный граф */

{{algorithm
| name = Нечеткий алгоритм C средних (Fuzzy C-means)
| serial_complexity = <math>O(C^2*N*D*IterNumber)</math>
| pf_height = <math>-</math>
| pf_width = <math>-</math>
| input_data = <math>-</math>
| output_data = <math>-</math>
}}

Авторы описания алгоритма: [[Участник:Demon smd|Д.А.Гуськов]] [[Участник:marina abramenkova|М.А.Абраменкова]]

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===
Нечёткий алгоритм кластеризации С-средних был разработан (для случая m=2) J.C. Dunn в 1973 г.
<ref>Dunn, J. C. (1973-01-01). "A Fuzzy Relative of the ISODATA Process and Its Use in Detecting Compact Well-Separated Clusters". Journal of Cybernetics. 3 (3): 32–57. doi:10.1080/01969727308546046. ISSN 0022-0280.</ref>
и усовершенствован (для случая m>1)
J.C. Bezdek в 1981 г. <ref>Bezdek, James C. (1981). Pattern Recognition with Fuzzy Objective Function Algorithms. ISBN 0-306-40671-3.</ref>
. В отличие от алгоритма c-means Данный метод кластеризации предполагает, что входные данные могут принадлежать более, чем одному кластеру одновременно.
Алгоритм получает на вход набор кластеризируемых векторов, количество кластеров, коэффициент неопределённости m и коэффициент <math>\varepsilon > 0</math>, определяющий точность алгоритма. На выходе алгоритма получаем матрицу вероятностей принадлежности каждого входного вектора каждому кластеру.

Нечеткий алгоритм С средних для каждого вектора определяет случайным образом значения принадлежности вектора к каждому кластеру и запускает итерационный процесс, на каждой итерации которого происходит:

1) Расчёт центров кластеров.

2) Расчёт Евклидова расстояния от каждого вектора до центра каждого кластера

3) Расчёт и нормализация коэффициентов принадлежности векторов кластерам

4) Расчёт значения решающей функции и сравнение этого значения со значением решающей функции на предшествующей итерации.Если их разница меньше установленного значения, то алгоритм прекращает работу. Решающая функция возвращает сумму всех Евклидовых расстояний каждого объекта к каждому центру кластера умноженному на коэффициент принадлежности

=== Математическое описание алгоритма ===
Нечеткий алгоритм С средних минимизирует величину:
:<math>
\begin{align}
J_{m} = \sum_{i = 1}^{N}\sum_{j = 1}^{C}u_{i,j}^m\left\Vert{x_{i}-c_{j}}\right\|^2 & & , & & 1 \le m \le \infty & ; \\
\end{align}
</math>

где m - это действительное число не меньше единицы, <math>u_{i,j}</math> - коэффициент принадлежности вектора <math>x_{i}</math> к кластеру <math>c_{j}</math>, <math>x_{i}</math> - <math>i</math>-ый компонент <math>N</math>-мерного вектора <math>x</math>, <math>c_{j}</math>
- центр <math>j</math>-ого кластера, а <math>\left\Vert{*}\right\|</math> - это любая норма, определяющая расстояние от вектора до центра кластера.
Нечёткое разбиение входных данных на кластеры производится итеративной оптимизацией вышеуказанной функции с обновлением коэффициента принадлежности <math>u_{i,j}</math> и переопределением центра кластера <math>c_{j}</math> на каждой итерации алгоритма.

==== Вычисляемые данные на каждой итерации ====
* Центры кластеров рассчитываются по следующей формуле: <math>c_{j} = {{\sum_{i = 1}^{n}{u_{i,j}^m} * x_{i}} \over {\sum_{i = 1}^{n}{u_{i,j}^m}}}</math>, где <math>u_{i,j}</math> — коэффициент принадлежности <math>x_{i}</math> вектора к кластеру <math>c_{j}</math>.

* Коэффициент принадлежности рассчитывается по формуле: <math>u_{i,j} = {1 \over \sum_{k = 1}^{C}{({\left\Vert{x_{i}-c_{j}}\right\| \over \left\Vert{x_{i}-c_{k}}\right\|})}^{2 \over m-1}}</math>

* Решающая функция рассчитывается по формуле: <math>\max_{i,j}(|u_{i,j}^{(k)} - u_{i,j}^{(k-1)}|)</math>, где <math>k</math> - номер итерации алгоритма

=== Вычислительное ядро алгоритма ===

Из вышесказанного следует, что ядром алгоритма является вычисление нового центра кластеров, для каждого входного вектора вычисление Евклидова расстояния до центров кластеров, а также коэффициент принадлежности и вычисления решающей функции.

=== Макроструктура алгоритма ===

В каждой итерации алгоритма происходит 3 основных действия описанных в п. 1.2.1:
*вычисление центров кластеров
*вычисление коэффициентов принадлежности
*вычисление решающей функции
Подробное описание макроструктур в виде кода приведено в пункте 1.5

=== Схема реализации последовательного алгоритма ===

Схему реализации последовательного алгоритма можно описать на C++ следующим образом:

<source lang="C++">

FCM (X[], C, m, eps){
float deside = 0;
float newDeside = 0;
generateMembershipDegree(); //заполняет uPrev[][] случайными нормрованными коэффициентами
while (true){
newDeside = deside;

//вычисление центров кластеров
for (int j=0; j<C; j++){ //для каждого кластера
float numerator = 0;
float denumerator = 0;
for (int i=0; i<X.size(); i++){ //для каждого вектора
numerator+=pow(u[i][j], m) * x[i];
denumerator+=pow(u[i][j], m);
}
c[j] = numerator / denumerator;
}

//вычисление коэффициентов u[][]
for (int i=0; i<X.size(); i++) //для каждого вектора
for (int j=0; j<C; j++){ //для каждого кластера
sum = 0;
for (int k=0; k<C; k++)
sum+= pow( dist(x[i], c[j]) / dist(x[i], c[k]), 2/(m-1));
u[i][j] = 1/sum
}

//определения максимального различия между u[][] и uPrev[][]
float max = 0;
for (int i=0; i<X.size(); i++) //для каждого вектора
for (int j=0; j<C; j++){ //для каждого кластера
if (abs(uPrev[i][j]-u[i][j])>max)
max = abs(uPrev[i][j]-u[i][j]);

if (eps <= max)
for (int i=0; i<X.size(); i++) //для каждого вектора
for (int j=0; j<C; j++){ //для каждого кластера
uPrev[i][j]=u[i][j];
else
break;

}
return u;
}
</source>

=== Последовательная сложность алгоритма ===

Последовательная сложность всего алгоритма складывается из сложности операций на каждой итерации умноженную на количество итераций. Так как в данном алгоритме количество итераций не является фиксированным и зависит от:
* параметра <math>\varepsilon</math>
* набора входных векторов <math>x</math>
* выбора начальных коэффициентов <math>u</math>
то в данном пункте будет приведена сложность одной итерации относительно количества входных векторов.
Как видно из предыдущего пункта, для вычисления центров кластеров требуется <math>O(2*C*N)</math> операций, для определения коэффициентов <math>u</math> - <math>O(C^2*N*D)</math> операций, а для вычисления решающей функции - <math>O(2*C*N)</math> операций, где <math>N</math> - число входных векторов, <math>C</math> - количество кластеров, а <math>D</math> - количество операций, требуемых для вычисления Евклидова расстояния между вектором и центром кластера.

Таким образом итоговая сложность одной итерации составляет <math>O(C^2*N*D)</math>.

=== Информационный граф ===

Как видно из пункта 1.5, на каждом действии каждой итерации алгоритма все операции, выполняющиеся в цикле, не зависят друг от друга и могут быть распаралелены. Это показано на Рисунке 1.

[[file:1.png|thumb|center|1400px|Рисунок 1. Информационный граф алгоритма, где /, <, := - операции деления, сравнения и присваивания соответственно. (1) - это последовательный набор операций возведения в степень, умножения, сложения и присваивания, а (2) - это последовательный набор операций ]]

=== Ресурс параллелизма алгоритма ===

=== Входные и выходные данные алгоритма ===

==== Входные данные алгоритма ====
* <math>x_{i}</math> - набор входных векторов
* <math>C</math> - количество кластеров
* <math>m</math> - коэффициент неопределённости
* <math>\varepsilon > 0</math> - коэффициент, определяющий точность алгоритма.

==== Выходные данные алгоритма ====
* <math>u</math> - матрица принадлежности векторов кластерам

=== Свойства алгоритма ===

== Литература ==

<references \>

Участник:Demon smd/Нечеткий алгоритм С средних

2016-10-02T10:04:36Z

Marina abramenkova: /* Схема реализации последовательного алгоритма */

{{algorithm
| name = Нечеткий алгоритм C средних (Fuzzy C-means)
| serial_complexity = <math>O(C^2*N*D*IterNumber)</math>
| pf_height = <math>-</math>
| pf_width = <math>-</math>
| input_data = <math>-</math>
| output_data = <math>-</math>
}}

Авторы описания алгоритма: [[Участник:Demon smd|Д.А.Гуськов]] [[Участник:marina abramenkova|М.А.Абраменкова]]

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===
Нечёткий алгоритм кластеризации С-средних был разработан (для случая m=2) J.C. Dunn в 1973 г.
<ref>Dunn, J. C. (1973-01-01). "A Fuzzy Relative of the ISODATA Process and Its Use in Detecting Compact Well-Separated Clusters". Journal of Cybernetics. 3 (3): 32–57. doi:10.1080/01969727308546046. ISSN 0022-0280.</ref>
и усовершенствован (для случая m>1)
J.C. Bezdek в 1981 г. <ref>Bezdek, James C. (1981). Pattern Recognition with Fuzzy Objective Function Algorithms. ISBN 0-306-40671-3.</ref>
. В отличие от алгоритма c-means Данный метод кластеризации предполагает, что входные данные могут принадлежать более, чем одному кластеру одновременно.
Алгоритм получает на вход набор кластеризируемых векторов, количество кластеров, коэффициент неопределённости m и коэффициент <math>\varepsilon > 0</math>, определяющий точность алгоритма. На выходе алгоритма получаем матрицу вероятностей принадлежности каждого входного вектора каждому кластеру.

Нечеткий алгоритм С средних для каждого вектора определяет случайным образом значения принадлежности вектора к каждому кластеру и запускает итерационный процесс, на каждой итерации которого происходит:

1) Расчёт центров кластеров.

2) Расчёт Евклидова расстояния от каждого вектора до центра каждого кластера

3) Расчёт и нормализация коэффициентов принадлежности векторов кластерам

4) Расчёт значения решающей функции и сравнение этого значения со значением решающей функции на предшествующей итерации.Если их разница меньше установленного значения, то алгоритм прекращает работу. Решающая функция возвращает сумму всех Евклидовых расстояний каждого объекта к каждому центру кластера умноженному на коэффициент принадлежности

=== Математическое описание алгоритма ===
Нечеткий алгоритм С средних минимизирует величину:
:<math>
\begin{align}
J_{m} = \sum_{i = 1}^{N}\sum_{j = 1}^{C}u_{i,j}^m\left\Vert{x_{i}-c_{j}}\right\|^2 & & , & & 1 \le m \le \infty & ; \\
\end{align}
</math>

где m - это действительное число не меньше единицы, <math>u_{i,j}</math> - коэффициент принадлежности вектора <math>x_{i}</math> к кластеру <math>c_{j}</math>, <math>x_{i}</math> - <math>i</math>-ый компонент <math>N</math>-мерного вектора <math>x</math>, <math>c_{j}</math>
- центр <math>j</math>-ого кластера, а <math>\left\Vert{*}\right\|</math> - это любая норма, определяющая расстояние от вектора до центра кластера.
Нечёткое разбиение входных данных на кластеры производится итеративной оптимизацией вышеуказанной функции с обновлением коэффициента принадлежности <math>u_{i,j}</math> и переопределением центра кластера <math>c_{j}</math> на каждой итерации алгоритма.

==== Вычисляемые данные на каждой итерации ====
* Центры кластеров рассчитываются по следующей формуле: <math>c_{j} = {{\sum_{i = 1}^{n}{u_{i,j}^m} * x_{i}} \over {\sum_{i = 1}^{n}{u_{i,j}^m}}}</math>, где <math>u_{i,j}</math> — коэффициент принадлежности <math>x_{i}</math> вектора к кластеру <math>c_{j}</math>.

* Коэффициент принадлежности рассчитывается по формуле: <math>u_{i,j} = {1 \over \sum_{k = 1}^{C}{({\left\Vert{x_{i}-c_{j}}\right\| \over \left\Vert{x_{i}-c_{k}}\right\|})}^{2 \over m-1}}</math>

* Решающая функция рассчитывается по формуле: <math>\max_{i,j}(|u_{i,j}^{(k)} - u_{i,j}^{(k-1)}|)</math>, где <math>k</math> - номер итерации алгоритма

=== Вычислительное ядро алгоритма ===

Из вышесказанного следует, что ядром алгоритма является вычисление нового центра кластеров, для каждого входного вектора вычисление Евклидова расстояния до центров кластеров, а также коэффициент принадлежности и вычисления решающей функции.

=== Макроструктура алгоритма ===

В каждой итерации алгоритма происходит 3 основных действия описанных в п. 1.2.1:
*вычисление центров кластеров
*вычисление коэффициентов принадлежности
*вычисление решающей функции
Подробное описание макроструктур в виде кода приведено в пункте 1.5

=== Схема реализации последовательного алгоритма ===

Схему реализации последовательного алгоритма можно описать на C++ следующим образом:

<source lang="C++">

FCM (X[], C, m, eps){
float deside = 0;
float newDeside = 0;
generateMembershipDegree(); //заполняет uPrev[][] случайными нормрованными коэффициентами
while (true){
newDeside = deside;

//вычисление центров кластеров
for (int j=0; j<C; j++){ //для каждого кластера
float numerator = 0;
float denumerator = 0;
for (int i=0; i<X.size(); i++){ //для каждого вектора
numerator+=pow(u[i][j], m) * x[i];
denumerator+=pow(u[i][j], m);
}
c[j] = numerator / denumerator;
}

//вычисление коэффициентов u[][]
for (int i=0; i<X.size(); i++) //для каждого вектора
for (int j=0; j<C; j++){ //для каждого кластера
sum = 0;
for (int k=0; k<C; k++)
sum+= pow( dist(x[i], c[j]) / dist(x[i], c[k]), 2/(m-1));
u[i][j] = 1/sum
}

//определения максимального различия между u[][] и uPrev[][]
float max = 0;
for (int i=0; i<X.size(); i++) //для каждого вектора
for (int j=0; j<C; j++){ //для каждого кластера
if (abs(uPrev[i][j]-u[i][j])>max)
max = abs(uPrev[i][j]-u[i][j]);

if (eps <= max)
for (int i=0; i<X.size(); i++) //для каждого вектора
for (int j=0; j<C; j++){ //для каждого кластера
uPrev[i][j]=u[i][j];
else
break;

}
return u;
}
</source>

=== Последовательная сложность алгоритма ===

Последовательная сложность всего алгоритма складывается из сложности операций на каждой итерации умноженную на количество итераций. Так как в данном алгоритме количество итераций не является фиксированным и зависит от:
* параметра <math>\varepsilon</math>
* набора входных векторов <math>x</math>
* выбора начальных коэффициентов <math>u</math>
то в данном пункте будет приведена сложность одной итерации относительно количества входных векторов.
Как видно из предыдущего пункта, для вычисления центров кластеров требуется <math>O(2*C*N)</math> операций, для определения коэффициентов <math>u</math> - <math>O(C^2*N*D)</math> операций, а для вычисления решающей функции - <math>O(2*C*N)</math> операций, где <math>N</math> - число входных векторов, <math>C</math> - количество кластеров, а <math>D</math> - количество операций, требуемых для вычисления Евклидова расстояния между вектором и центром кластера.

Таким образом итоговая сложность одной итерации составляет <math>O(C^2*N*D)</math>.

=== Информационный граф ===

=== Ресурс параллелизма алгоритма ===

=== Входные и выходные данные алгоритма ===

==== Входные данные алгоритма ====
* <math>x_{i}</math> - набор входных векторов
* <math>C</math> - количество кластеров
* <math>m</math> - коэффициент неопределённости
* <math>\varepsilon > 0</math> - коэффициент, определяющий точность алгоритма.

==== Выходные данные алгоритма ====
* <math>u</math> - матрица принадлежности векторов кластерам

=== Свойства алгоритма ===

== Литература ==

<references \>

Участник:Demon smd/Нечеткий алгоритм С средних

2016-10-02T10:04:06Z

Marina abramenkova: /* Схема реализации последовательного алгоритма */

{{algorithm
| name = Нечеткий алгоритм C средних (Fuzzy C-means)
| serial_complexity = <math>O(C^2*N*D*IterNumber)</math>
| pf_height = <math>-</math>
| pf_width = <math>-</math>
| input_data = <math>-</math>
| output_data = <math>-</math>
}}

Авторы описания алгоритма: [[Участник:Demon smd|Д.А.Гуськов]] [[Участник:marina abramenkova|М.А.Абраменкова]]

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===
Нечёткий алгоритм кластеризации С-средних был разработан (для случая m=2) J.C. Dunn в 1973 г.
<ref>Dunn, J. C. (1973-01-01). "A Fuzzy Relative of the ISODATA Process and Its Use in Detecting Compact Well-Separated Clusters". Journal of Cybernetics. 3 (3): 32–57. doi:10.1080/01969727308546046. ISSN 0022-0280.</ref>
и усовершенствован (для случая m>1)
J.C. Bezdek в 1981 г. <ref>Bezdek, James C. (1981). Pattern Recognition with Fuzzy Objective Function Algorithms. ISBN 0-306-40671-3.</ref>
. В отличие от алгоритма c-means Данный метод кластеризации предполагает, что входные данные могут принадлежать более, чем одному кластеру одновременно.
Алгоритм получает на вход набор кластеризируемых векторов, количество кластеров, коэффициент неопределённости m и коэффициент <math>\varepsilon > 0</math>, определяющий точность алгоритма. На выходе алгоритма получаем матрицу вероятностей принадлежности каждого входного вектора каждому кластеру.

Нечеткий алгоритм С средних для каждого вектора определяет случайным образом значения принадлежности вектора к каждому кластеру и запускает итерационный процесс, на каждой итерации которого происходит:

1) Расчёт центров кластеров.

2) Расчёт Евклидова расстояния от каждого вектора до центра каждого кластера

3) Расчёт и нормализация коэффициентов принадлежности векторов кластерам

4) Расчёт значения решающей функции и сравнение этого значения со значением решающей функции на предшествующей итерации.Если их разница меньше установленного значения, то алгоритм прекращает работу. Решающая функция возвращает сумму всех Евклидовых расстояний каждого объекта к каждому центру кластера умноженному на коэффициент принадлежности

=== Математическое описание алгоритма ===
Нечеткий алгоритм С средних минимизирует величину:
:<math>
\begin{align}
J_{m} = \sum_{i = 1}^{N}\sum_{j = 1}^{C}u_{i,j}^m\left\Vert{x_{i}-c_{j}}\right\|^2 & & , & & 1 \le m \le \infty & ; \\
\end{align}
</math>

где m - это действительное число не меньше единицы, <math>u_{i,j}</math> - коэффициент принадлежности вектора <math>x_{i}</math> к кластеру <math>c_{j}</math>, <math>x_{i}</math> - <math>i</math>-ый компонент <math>N</math>-мерного вектора <math>x</math>, <math>c_{j}</math>
- центр <math>j</math>-ого кластера, а <math>\left\Vert{*}\right\|</math> - это любая норма, определяющая расстояние от вектора до центра кластера.
Нечёткое разбиение входных данных на кластеры производится итеративной оптимизацией вышеуказанной функции с обновлением коэффициента принадлежности <math>u_{i,j}</math> и переопределением центра кластера <math>c_{j}</math> на каждой итерации алгоритма.

==== Вычисляемые данные на каждой итерации ====
* Центры кластеров рассчитываются по следующей формуле: <math>c_{j} = {{\sum_{i = 1}^{n}{u_{i,j}^m} * x_{i}} \over {\sum_{i = 1}^{n}{u_{i,j}^m}}}</math>, где <math>u_{i,j}</math> — коэффициент принадлежности <math>x_{i}</math> вектора к кластеру <math>c_{j}</math>.

* Коэффициент принадлежности рассчитывается по формуле: <math>u_{i,j} = {1 \over \sum_{k = 1}^{C}{({\left\Vert{x_{i}-c_{j}}\right\| \over \left\Vert{x_{i}-c_{k}}\right\|})}^{2 \over m-1}}</math>

* Решающая функция рассчитывается по формуле: <math>\max_{i,j}(|u_{i,j}^{(k)} - u_{i,j}^{(k-1)}|)</math>, где <math>k</math> - номер итерации алгоритма

=== Вычислительное ядро алгоритма ===

Из вышесказанного следует, что ядром алгоритма является вычисление нового центра кластеров, для каждого входного вектора вычисление Евклидова расстояния до центров кластеров, а также коэффициент принадлежности и вычисления решающей функции.

=== Макроструктура алгоритма ===

В каждой итерации алгоритма происходит 3 основных действия описанных в п. 1.2.1:
*вычисление центров кластеров
*вычисление коэффициентов принадлежности
*вычисление решающей функции
Подробное описание макроструктур в виде кода приведено в пункте 1.5

=== Схема реализации последовательного алгоритма ===

Схему реализации последовательного алгоритма можно описать на C++ следующим образом:

<source lang="C++">

FCM (X[], C, m, eps){
float deside = 0;
float newDeside = 0;
generateMembershipDegree(); //заполняет uPrev[][] случайными нормрованными коэффициентами
while (true){
newDeside = deside;

//вычисление центров кластеров
for (int j=0; j<C; j++){ //для каждого кластера
float numerator = 0;
float denumerator = 0;
for (int i=0; i<X.size(); i++){ //для каждого вектора
numerator+=pow(u[i][j], m) * x[i];
denumerator+=pow(u[i][j], m);
}
c[j] = numerator / denumerator;
}

//вычисление коэффициентов u[][]
for (int i=0; i<X; i++) //для каждого вектора
for (int j=0; j<C; j++){ //для каждого кластера
sum = 0;
for (int k=0; k<C; k++)
sum+= pow( dist(x[i], c[j]) / dist(x[i], c[k]), 2/(m-1));
u[i][j] = 1/sum
}

//определения максимального различия между u[][] и uPrev[][]
float max = 0;
for (int i=0; i<X; i++) //для каждого вектора
for (int j=0; j<C; j++){ //для каждого кластера
if (abs(uPrev[i][j]-u[i][j])>max)
max = abs(uPrev[i][j]-u[i][j]);

if (eps <= max)
for (int i=0; i<X; i++) //для каждого вектора
for (int j=0; j<C; j++){ //для каждого кластера
uPrev[i][j]=u[i][j];
else
break;

}
return u;
}
</source>

=== Последовательная сложность алгоритма ===

Последовательная сложность всего алгоритма складывается из сложности операций на каждой итерации умноженную на количество итераций. Так как в данном алгоритме количество итераций не является фиксированным и зависит от:
* параметра <math>\varepsilon</math>
* набора входных векторов <math>x</math>
* выбора начальных коэффициентов <math>u</math>
то в данном пункте будет приведена сложность одной итерации относительно количества входных векторов.
Как видно из предыдущего пункта, для вычисления центров кластеров требуется <math>O(2*C*N)</math> операций, для определения коэффициентов <math>u</math> - <math>O(C^2*N*D)</math> операций, а для вычисления решающей функции - <math>O(2*C*N)</math> операций, где <math>N</math> - число входных векторов, <math>C</math> - количество кластеров, а <math>D</math> - количество операций, требуемых для вычисления Евклидова расстояния между вектором и центром кластера.

Таким образом итоговая сложность одной итерации составляет <math>O(C^2*N*D)</math>.

=== Информационный граф ===

=== Ресурс параллелизма алгоритма ===

=== Входные и выходные данные алгоритма ===

==== Входные данные алгоритма ====
* <math>x_{i}</math> - набор входных векторов
* <math>C</math> - количество кластеров
* <math>m</math> - коэффициент неопределённости
* <math>\varepsilon > 0</math> - коэффициент, определяющий точность алгоритма.

==== Выходные данные алгоритма ====
* <math>u</math> - матрица принадлежности векторов кластерам

=== Свойства алгоритма ===

== Литература ==

<references \>

Участник:Demon smd/Нечеткий алгоритм С средних

2016-10-02T09:54:38Z

Marina abramenkova: /* Схема реализации последовательного алгоритма */

{{algorithm
| name = Нечеткий алгоритм C средних (Fuzzy C-means)
| serial_complexity = <math>O(C^2*N*D*IterNumber)</math>
| pf_height = <math>-</math>
| pf_width = <math>-</math>
| input_data = <math>-</math>
| output_data = <math>-</math>
}}

Авторы описания алгоритма: [[Участник:Demon smd|Д.А.Гуськов]] [[Участник:marina abramenkova|М.А.Абраменкова]]

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===
Нечёткий алгоритм кластеризации С-средних был разработан (для случая m=2) J.C. Dunn в 1973 г.
<ref>Dunn, J. C. (1973-01-01). "A Fuzzy Relative of the ISODATA Process and Its Use in Detecting Compact Well-Separated Clusters". Journal of Cybernetics. 3 (3): 32–57. doi:10.1080/01969727308546046. ISSN 0022-0280.</ref>
и усовершенствован (для случая m>1)
J.C. Bezdek в 1981 г. <ref>Bezdek, James C. (1981). Pattern Recognition with Fuzzy Objective Function Algorithms. ISBN 0-306-40671-3.</ref>
. В отличие от алгоритма c-means Данный метод кластеризации предполагает, что входные данные могут принадлежать более, чем одному кластеру одновременно.
Алгоритм получает на вход набор кластеризируемых векторов, количество кластеров, коэффициент неопределённости m и коэффициент <math>\varepsilon > 0</math>, определяющий точность алгоритма. На выходе алгоритма получаем матрицу вероятностей принадлежности каждого входного вектора каждому кластеру.

Нечеткий алгоритм С средних для каждого вектора определяет случайным образом значения принадлежности вектора к каждому кластеру и запускает итерационный процесс, на каждой итерации которого происходит:

1) Расчёт центров кластеров.

2) Расчёт Евклидова расстояния от каждого вектора до центра каждого кластера

3) Расчёт и нормализация коэффициентов принадлежности векторов кластерам

4) Расчёт значения решающей функции и сравнение этого значения со значением решающей функции на предшествующей итерации.Если их разница меньше установленного значения, то алгоритм прекращает работу. Решающая функция возвращает сумму всех Евклидовых расстояний каждого объекта к каждому центру кластера умноженному на коэффициент принадлежности

=== Математическое описание алгоритма ===
Нечеткий алгоритм С средних минимизирует величину:
:<math>
\begin{align}
J_{m} = \sum_{i = 1}^{N}\sum_{j = 1}^{C}u_{i,j}^m\left\Vert{x_{i}-c_{j}}\right\|^2 & & , & & 1 \le m \le \infty & ; \\
\end{align}
</math>

где m - это действительное число не меньше единицы, <math>u_{i,j}</math> - коэффициент принадлежности вектора <math>x_{i}</math> к кластеру <math>c_{j}</math>, <math>x_{i}</math> - <math>i</math>-ый компонент <math>N</math>-мерного вектора <math>x</math>, <math>c_{j}</math>
- центр <math>j</math>-ого кластера, а <math>\left\Vert{*}\right\|</math> - это любая норма, определяющая расстояние от вектора до центра кластера.
Нечёткое разбиение входных данных на кластеры производится итеративной оптимизацией вышеуказанной функции с обновлением коэффициента принадлежности <math>u_{i,j}</math> и переопределением центра кластера <math>c_{j}</math> на каждой итерации алгоритма.

==== Вычисляемые данные на каждой итерации ====
* Центры кластеров рассчитываются по следующей формуле: <math>c_{j} = {{\sum_{i = 1}^{n}{u_{i,j}^m} * x_{i}} \over {\sum_{i = 1}^{n}{u_{i,j}^m}}}</math>, где <math>u_{i,j}</math> — коэффициент принадлежности <math>x_{i}</math> вектора к кластеру <math>c_{j}</math>.

* Коэффициент принадлежности рассчитывается по формуле: <math>u_{i,j} = {1 \over \sum_{k = 1}^{C}{({\left\Vert{x_{i}-c_{j}}\right\| \over \left\Vert{x_{i}-c_{k}}\right\|})}^{2 \over m-1}}</math>

* Решающая функция рассчитывается по формуле: <math>\max_{i,j}(|u_{i,j}^{(k)} - u_{i,j}^{(k-1)}|)</math>, где <math>k</math> - номер итерации алгоритма

=== Вычислительное ядро алгоритма ===

Из вышесказанного следует, что ядром алгоритма является вычисление нового центра кластеров, для каждого входного вектора вычисление Евклидова расстояния до центров кластеров, а также коэффициент принадлежности и вычисления решающей функции.

=== Макроструктура алгоритма ===

В каждой итерации алгоритма происходит 3 основных действия описанных в п. 1.2.1:
*вычисление центров кластеров
*вычисление коэффициентов принадлежности
*вычисление решающей функции
Подробное описание макроструктур в виде кода приведено в пункте 1.5

=== Схема реализации последовательного алгоритма ===

Схему реализации последовательного алгоритма можно описать на C++ следующим образом:

<source lang="C++">

FCM (X[], C, m, eps){
float deside = 0;
float newDeside = 0;
generateMembershipDegree(); //заполняет uPrev[][] случайными нормрованными коэффициентами
while (true){
newDeside = deside;

//вычисление центров кластеров
for (int j=0; j<C; j++){ //для каждого кластера
float numerator = 0;
float denumerator = 0;
for (int i=0; i<X; i++){ //для каждого вектора
numerator+=pow(u[i][j], m) * x[i];
denumerator+=pow(u[i][j], m);
}
c[j] = numerator / denumerator;
}

//вычисление коэффициентов u[][]
for (int i=0; i<X; i++) //для каждого вектора
for (int j=0; j<C; j++){ //для каждого кластера
sum = 0;
for (int k=0; k<C; k++)
sum+= pow( dist(x[i], c[j]) / dist(x[i], c[k]), 2/(m-1));
u[i][j] = 1/sum
}

//определения максимального различия между u[][] и uPrev[][]
float max = 0;
for (int i=0; i<X; i++) //для каждого вектора
for (int j=0; j<C; j++){ //для каждого кластера
if (abs(uPrev[i][j]-u[i][j])>max)
max = abs(uPrev[i][j]-u[i][j]);

if (eps <= max)
for (int i=0; i<X; i++) //для каждого вектора
for (int j=0; j<C; j++){ //для каждого кластера
uPrev[i][j]=u[i][j];
else
break;

}
return u;
}
</source>

=== Последовательная сложность алгоритма ===

Последовательная сложность всего алгоритма складывается из сложности операций на каждой итерации умноженную на количество итераций. Так как в данном алгоритме количество итераций не является фиксированным и зависит от:
* параметра <math>\varepsilon</math>
* набора входных векторов <math>x</math>
* выбора начальных коэффициентов <math>u</math>
то в данном пункте будет приведена сложность одной итерации относительно количества входных векторов.
Как видно из предыдущего пункта, для вычисления центров кластеров требуется <math>O(2*C*N)</math> операций, для определения коэффициентов <math>u</math> - <math>O(C^2*N*D)</math> операций, а для вычисления решающей функции - <math>O(2*C*N)</math> операций, где <math>N</math> - число входных векторов, <math>C</math> - количество кластеров, а <math>D</math> - количество операций, требуемых для вычисления Евклидова расстояния между вектором и центром кластера.

Таким образом итоговая сложность одной итерации составляет <math>O(C^2*N*D)</math>.

=== Информационный граф ===

=== Ресурс параллелизма алгоритма ===

=== Входные и выходные данные алгоритма ===

==== Входные данные алгоритма ====
* <math>x_{i}</math> - набор входных векторов
* <math>C</math> - количество кластеров
* <math>m</math> - коэффициент неопределённости
* <math>\varepsilon > 0</math> - коэффициент, определяющий точность алгоритма.

==== Выходные данные алгоритма ====
* <math>u</math> - матрица принадлежности векторов кластерам

=== Свойства алгоритма ===

== Литература ==

<references \>

Участник:Demon smd/Нечеткий алгоритм С средних

2016-09-30T16:33:20Z

Marina abramenkova: /* Макроструктура алгоритма */

{{algorithm
| name = Нечеткий алгоритм C средних (Fuzzy C-means)
| serial_complexity = <math>O(C^2*N*D*IterNumber)</math>
| pf_height = <math>-</math>
| pf_width = <math>-</math>
| input_data = <math>-</math>
| output_data = <math>-</math>
}}

Авторы описания алгоритма: [[Участник:Demon smd|Д.А.Гуськов]] [[Участник:marina abramenkova|М.А.Абраменкова]]

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===
Нечёткий алгоритм кластеризации С-средних был разработан (для случая m=2) J.C. Dunn в 1973 г.
<ref>Dunn, J. C. (1973-01-01). "A Fuzzy Relative of the ISODATA Process and Its Use in Detecting Compact Well-Separated Clusters". Journal of Cybernetics. 3 (3): 32–57. doi:10.1080/01969727308546046. ISSN 0022-0280.</ref>
и усовершенствован (для случая m>1)
J.C. Bezdek в 1981 г. <ref>Bezdek, James C. (1981). Pattern Recognition with Fuzzy Objective Function Algorithms. ISBN 0-306-40671-3.</ref>
. В отличие от алгоритма c-means Данный метод кластеризации предполагает, что входные данные могут принадлежать более, чем одному кластеру одновременно.
Алгоритм получает на вход набор кластеризируемых векторов, количество кластеров, коэффициент неопределённости m и коэффициент <math>\varepsilon > 0</math>, определяющий точность алгоритма. На выходе алгоритма получаем матрицу вероятностей принадлежности каждого входного вектора каждому кластеру.

Нечеткий алгоритм С средних для каждого вектора определяет случайным образом значения принадлежности вектора к каждому кластеру и запускает итерационный процесс, на каждой итерации которого происходит:

1) Расчёт центров кластеров.

2) Расчёт Евклидова расстояния от каждого вектора до центра каждого кластера

3) Расчёт и нормализация коэффициентов принадлежности векторов кластерам

4) Расчёт значения решающей функции и сравнение этого значения со значением решающей функции на предшествующей итерации.Если их разница меньше установленного значения, то алгоритм прекращает работу. Решающая функция возвращает сумму всех Евклидовых расстояний каждого объекта к каждому центру кластера умноженному на коэффициент принадлежности

=== Математическое описание алгоритма ===
Нечеткий алгоритм С средних минимизирует величину:
:<math>
\begin{align}
J_{m} = \sum_{i = 1}^{N}\sum_{j = 1}^{C}u_{i,j}^m\left\Vert{x_{i}-c_{j}}\right\|^2 & & , & & 1 \le m \le \infty & ; \\
\end{align}
</math>

где m - это действительное число не меньше единицы, <math>u_{i,j}</math> - коэффициент принадлежности вектора <math>x_{i}</math> к кластеру <math>c_{j}</math>, <math>x_{i}</math> - <math>i</math>-ый компонент <math>N</math>-мерного вектора <math>x</math>, <math>c_{j}</math>
- центр <math>j</math>-ого кластера, а <math>\left\Vert{*}\right\|</math> - это любая норма, определяющая расстояние от вектора до центра кластера.
Нечёткое разбиение входных данных на кластеры производится итеративной оптимизацией вышеуказанной функции с обновлением коэффициента принадлежности <math>u_{i,j}</math> и переопределением центра кластера <math>c_{j}</math> на каждой итерации алгоритма.

==== Вычисляемые данные на каждой итерации ====
* Центры кластеров рассчитываются по следующей формуле: <math>c_{j} = {{\sum_{i = 1}^{n}{u_{i,j}^m} * x_{i}} \over {\sum_{i = 1}^{n}{u_{i,j}^m}}}</math>, где <math>u_{i,j}</math> — коэффициент принадлежности <math>x_{i}</math> вектора к кластеру <math>c_{j}</math>.

* Коэффициент принадлежности рассчитывается по формуле: <math>u_{i,j} = {1 \over \sum_{k = 1}^{C}{({\left\Vert{x_{i}-c_{j}}\right\| \over \left\Vert{x_{i}-c_{k}}\right\|})}^{2 \over m-1}}</math>

* Решающая функция рассчитывается по формуле: <math>\max_{i,j}(|u_{i,j}^{(k)} - u_{i,j}^{(k-1)}|)</math>, где <math>k</math> - номер итерации алгоритма

=== Вычислительное ядро алгоритма ===

Из вышесказанного следует, что ядром алгоритма является вычисление нового центра кластеров, для каждого входного вектора вычисление Евклидова расстояния до центров кластеров, а также коэффициент принадлежности и вычисления решающей функции.

=== Макроструктура алгоритма ===

В каждой итерации алгоритма происходит 3 основных действия описанных в п. 1.2.1:
*вычисление центров кластеров
*вычисление коэффициентов принадлежности
*вычисление решающей функции
Подробное описание макроструктур в виде кода приведено в пункте 1.5

=== Схема реализации последовательного алгоритма ===

Схему реализации последовательного алгоритма можно описать на C++ следующим образом:

<source lang="C++">

FCM (X[], C[], m, eps){
float deside = 0;
float newDeside = 0;
generateMembershipDegree(); //заполняет uPrev[][] случайными нормрованными коэффициентами
while (true){
newDeside = deside;

//вычисление центров кластеров
for (int j=0; j<C; j++){ //для каждого кластера
float numerator = 0;
float denumerator = 0;
for (int i=0; i<X; i++){ //для каждого вектора
numerator+=pow(u[i][j], m) * x[i];
denumerator+=pow(u[i][j], m);
}
c[j] = numerator / denumerator;
}

//вычисление коэффициентов u[][]
for (int i=0; i<X; i++) //для каждого вектора
for (int j=0; j<C; j++){ //для каждого кластера
sum = 0;
for (int k=0; k<C; k++)
sum+= pow( dist(x[i], c[j]) / dist(x[i], c[k]), 2/(m-1));
u[i][j] = 1/sum
}

//определения максимального различия между u[][] и uPrev[][]
float max = 0;
for (int i=0; i<X; i++) //для каждого вектора
for (int j=0; j<C; j++){ //для каждого кластера
if (abs(uPrev[i][j]-u[i][j])>max)
max = abs(uPrev[i][j]-u[i][j]);

if (eps <= max)
for (int i=0; i<X; i++) //для каждого вектора
for (int j=0; j<C; j++){ //для каждого кластера
uPrev[i][j]=u[i][j];
else
break;

}
return u;
}
</source>

=== Последовательная сложность алгоритма ===

Последовательная сложность всего алгоритма складывается из сложности операций на каждой итерации умноженную на количество итераций. Так как в данном алгоритме количество итераций не является фиксированным и зависит от:
* параметра <math>\varepsilon</math>
* набора входных векторов <math>x</math>
* выбора начальных коэффициентов <math>u</math>
то в данном пункте будет приведена сложность одной итерации относительно количества входных векторов.
Как видно из предыдущего пункта, для вычисления центров кластеров требуется <math>O(2*C*N)</math> операций, для определения коэффициентов <math>u</math> - <math>O(C^2*N*D)</math> операций, а для вычисления решающей функции - <math>O(2*C*N)</math> операций, где <math>N</math> - число входных векторов, <math>C</math> - количество кластеров, а <math>D</math> - количество операций, требуемых для вычисления Евклидова расстояния между вектором и центром кластера.

Таким образом итоговая сложность одной итерации составляет <math>O(C^2*N*D)</math>.

=== Информационный граф ===

=== Ресурс параллелизма алгоритма ===

=== Входные и выходные данные алгоритма ===

==== Входные данные алгоритма ====
* <math>x_{i}</math> - набор входных векторов
* <math>C</math> - количество кластеров
* <math>m</math> - коэффициент неопределённости
* <math>\varepsilon > 0</math> - коэффициент, определяющий точность алгоритма.

==== Выходные данные алгоритма ====
* <math>u</math> - матрица принадлежности векторов кластерам

=== Свойства алгоритма ===

== Литература ==

<references \>

Участник:Demon smd/Нечеткий алгоритм С средних

2016-09-30T16:27:56Z

Marina abramenkova: /* Вычисляемые данные на каждой итерации */

{{algorithm
| name = Нечеткий алгоритм C средних (Fuzzy C-means)
| serial_complexity = <math>O(C^2*N*D*IterNumber)</math>
| pf_height = <math>-</math>
| pf_width = <math>-</math>
| input_data = <math>-</math>
| output_data = <math>-</math>
}}

Авторы описания алгоритма: [[Участник:Demon smd|Д.А.Гуськов]] [[Участник:marina abramenkova|М.А.Абраменкова]]

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===
Нечёткий алгоритм кластеризации С-средних был разработан (для случая m=2) J.C. Dunn в 1973 г.
<ref>Dunn, J. C. (1973-01-01). "A Fuzzy Relative of the ISODATA Process and Its Use in Detecting Compact Well-Separated Clusters". Journal of Cybernetics. 3 (3): 32–57. doi:10.1080/01969727308546046. ISSN 0022-0280.</ref>
и усовершенствован (для случая m>1)
J.C. Bezdek в 1981 г. <ref>Bezdek, James C. (1981). Pattern Recognition with Fuzzy Objective Function Algorithms. ISBN 0-306-40671-3.</ref>
. В отличие от алгоритма c-means Данный метод кластеризации предполагает, что входные данные могут принадлежать более, чем одному кластеру одновременно.
Алгоритм получает на вход набор кластеризируемых векторов, количество кластеров, коэффициент неопределённости m и коэффициент <math>\varepsilon > 0</math>, определяющий точность алгоритма. На выходе алгоритма получаем матрицу вероятностей принадлежности каждого входного вектора каждому кластеру.

Нечеткий алгоритм С средних для каждого вектора определяет случайным образом значения принадлежности вектора к каждому кластеру и запускает итерационный процесс, на каждой итерации которого происходит:

1) Расчёт центров кластеров.

2) Расчёт Евклидова расстояния от каждого вектора до центра каждого кластера

3) Расчёт и нормализация коэффициентов принадлежности векторов кластерам

4) Расчёт значения решающей функции и сравнение этого значения со значением решающей функции на предшествующей итерации.Если их разница меньше установленного значения, то алгоритм прекращает работу. Решающая функция возвращает сумму всех Евклидовых расстояний каждого объекта к каждому центру кластера умноженному на коэффициент принадлежности

=== Математическое описание алгоритма ===
Нечеткий алгоритм С средних минимизирует величину:
:<math>
\begin{align}
J_{m} = \sum_{i = 1}^{N}\sum_{j = 1}^{C}u_{i,j}^m\left\Vert{x_{i}-c_{j}}\right\|^2 & & , & & 1 \le m \le \infty & ; \\
\end{align}
</math>

где m - это действительное число не меньше единицы, <math>u_{i,j}</math> - коэффициент принадлежности вектора <math>x_{i}</math> к кластеру <math>c_{j}</math>, <math>x_{i}</math> - <math>i</math>-ый компонент <math>N</math>-мерного вектора <math>x</math>, <math>c_{j}</math>
- центр <math>j</math>-ого кластера, а <math>\left\Vert{*}\right\|</math> - это любая норма, определяющая расстояние от вектора до центра кластера.
Нечёткое разбиение входных данных на кластеры производится итеративной оптимизацией вышеуказанной функции с обновлением коэффициента принадлежности <math>u_{i,j}</math> и переопределением центра кластера <math>c_{j}</math> на каждой итерации алгоритма.

==== Вычисляемые данные на каждой итерации ====
* Центры кластеров рассчитываются по следующей формуле: <math>c_{j} = {{\sum_{i = 1}^{n}{u_{i,j}^m} * x_{i}} \over {\sum_{i = 1}^{n}{u_{i,j}^m}}}</math>, где <math>u_{i,j}</math> — коэффициент принадлежности <math>x_{i}</math> вектора к кластеру <math>c_{j}</math>.

* Коэффициент принадлежности рассчитывается по формуле: <math>u_{i,j} = {1 \over \sum_{k = 1}^{C}{({\left\Vert{x_{i}-c_{j}}\right\| \over \left\Vert{x_{i}-c_{k}}\right\|})}^{2 \over m-1}}</math>

* Решающая функция рассчитывается по формуле: <math>\max_{i,j}(|u_{i,j}^{(k)} - u_{i,j}^{(k-1)}|)</math>, где <math>k</math> - номер итерации алгоритма

=== Вычислительное ядро алгоритма ===

Из вышесказанного следует, что ядром алгоритма является вычисление нового центра кластеров, для каждого входного вектора вычисление Евклидова расстояния до центров кластеров, а также коэффициент принадлежности и вычисления решающей функции.

=== Макроструктура алгоритма ===

=== Схема реализации последовательного алгоритма ===

Схему реализации последовательного алгоритма можно описать на C++ следующим образом:

<source lang="C++">

FCM (X[], C[], m, eps){
float deside = 0;
float newDeside = 0;
generateMembershipDegree(); //заполняет uPrev[][] случайными нормрованными коэффициентами
while (true){
newDeside = deside;

//вычисление центров кластеров
for (int j=0; j<C; j++){ //для каждого кластера
float numerator = 0;
float denumerator = 0;
for (int i=0; i<X; i++){ //для каждого вектора
numerator+=pow(u[i][j], m) * x[i];
denumerator+=pow(u[i][j], m);
}
c[j] = numerator / denumerator;
}

//вычисление коэффициентов u[][]
for (int i=0; i<X; i++) //для каждого вектора
for (int j=0; j<C; j++){ //для каждого кластера
sum = 0;
for (int k=0; k<C; k++)
sum+= pow( dist(x[i], c[j]) / dist(x[i], c[k]), 2/(m-1));
u[i][j] = 1/sum
}

//определения максимального различия между u[][] и uPrev[][]
float max = 0;
for (int i=0; i<X; i++) //для каждого вектора
for (int j=0; j<C; j++){ //для каждого кластера
if (abs(uPrev[i][j]-u[i][j])>max)
max = abs(uPrev[i][j]-u[i][j]);

if (eps <= max)
for (int i=0; i<X; i++) //для каждого вектора
for (int j=0; j<C; j++){ //для каждого кластера
uPrev[i][j]=u[i][j];
else
break;

}
return u;
}
</source>

=== Последовательная сложность алгоритма ===

Последовательная сложность всего алгоритма складывается из сложности операций на каждой итерации умноженную на количество итераций. Так как в данном алгоритме количество итераций не является фиксированным и зависит от:
* параметра <math>\varepsilon</math>
* набора входных векторов <math>x</math>
* выбора начальных коэффициентов <math>u</math>
то в данном пункте будет приведена сложность одной итерации относительно количества входных векторов.
Как видно из предыдущего пункта, для вычисления центров кластеров требуется <math>O(2*C*N)</math> операций, для определения коэффициентов <math>u</math> - <math>O(C^2*N*D)</math> операций, а для вычисления решающей функции - <math>O(2*C*N)</math> операций, где <math>N</math> - число входных векторов, <math>C</math> - количество кластеров, а <math>D</math> - количество операций, требуемых для вычисления Евклидова расстояния между вектором и центром кластера.

Таким образом итоговая сложность одной итерации составляет <math>O(C^2*N*D)</math>.

=== Информационный граф ===

=== Ресурс параллелизма алгоритма ===

=== Входные и выходные данные алгоритма ===

==== Входные данные алгоритма ====
* <math>x_{i}</math> - набор входных векторов
* <math>C</math> - количество кластеров
* <math>m</math> - коэффициент неопределённости
* <math>\varepsilon > 0</math> - коэффициент, определяющий точность алгоритма.

==== Выходные данные алгоритма ====
* <math>u</math> - матрица принадлежности векторов кластерам

=== Свойства алгоритма ===

== Литература ==

<references \>

Участник:Demon smd/Нечеткий алгоритм С средних

2016-09-30T16:27:40Z

Marina abramenkova: /* Вычисляемые данные на каждой итерации */

{{algorithm
| name = Нечеткий алгоритм C средних (Fuzzy C-means)
| serial_complexity = <math>O(C^2*N*D*IterNumber)</math>
| pf_height = <math>-</math>
| pf_width = <math>-</math>
| input_data = <math>-</math>
| output_data = <math>-</math>
}}

Авторы описания алгоритма: [[Участник:Demon smd|Д.А.Гуськов]] [[Участник:marina abramenkova|М.А.Абраменкова]]

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===
Нечёткий алгоритм кластеризации С-средних был разработан (для случая m=2) J.C. Dunn в 1973 г.
<ref>Dunn, J. C. (1973-01-01). "A Fuzzy Relative of the ISODATA Process and Its Use in Detecting Compact Well-Separated Clusters". Journal of Cybernetics. 3 (3): 32–57. doi:10.1080/01969727308546046. ISSN 0022-0280.</ref>
и усовершенствован (для случая m>1)
J.C. Bezdek в 1981 г. <ref>Bezdek, James C. (1981). Pattern Recognition with Fuzzy Objective Function Algorithms. ISBN 0-306-40671-3.</ref>
. В отличие от алгоритма c-means Данный метод кластеризации предполагает, что входные данные могут принадлежать более, чем одному кластеру одновременно.
Алгоритм получает на вход набор кластеризируемых векторов, количество кластеров, коэффициент неопределённости m и коэффициент <math>\varepsilon > 0</math>, определяющий точность алгоритма. На выходе алгоритма получаем матрицу вероятностей принадлежности каждого входного вектора каждому кластеру.

Нечеткий алгоритм С средних для каждого вектора определяет случайным образом значения принадлежности вектора к каждому кластеру и запускает итерационный процесс, на каждой итерации которого происходит:

1) Расчёт центров кластеров.

2) Расчёт Евклидова расстояния от каждого вектора до центра каждого кластера

3) Расчёт и нормализация коэффициентов принадлежности векторов кластерам

4) Расчёт значения решающей функции и сравнение этого значения со значением решающей функции на предшествующей итерации.Если их разница меньше установленного значения, то алгоритм прекращает работу. Решающая функция возвращает сумму всех Евклидовых расстояний каждого объекта к каждому центру кластера умноженному на коэффициент принадлежности

=== Математическое описание алгоритма ===
Нечеткий алгоритм С средних минимизирует величину:
:<math>
\begin{align}
J_{m} = \sum_{i = 1}^{N}\sum_{j = 1}^{C}u_{i,j}^m\left\Vert{x_{i}-c_{j}}\right\|^2 & & , & & 1 \le m \le \infty & ; \\
\end{align}
</math>

где m - это действительное число не меньше единицы, <math>u_{i,j}</math> - коэффициент принадлежности вектора <math>x_{i}</math> к кластеру <math>c_{j}</math>, <math>x_{i}</math> - <math>i</math>-ый компонент <math>N</math>-мерного вектора <math>x</math>, <math>c_{j}</math>
- центр <math>j</math>-ого кластера, а <math>\left\Vert{*}\right\|</math> - это любая норма, определяющая расстояние от вектора до центра кластера.
Нечёткое разбиение входных данных на кластеры производится итеративной оптимизацией вышеуказанной функции с обновлением коэффициента принадлежности <math>u_{i,j}</math> и переопределением центра кластера <math>c_{j}</math> на каждой итерации алгоритма.

==== Вычисляемые данные на каждой итерации ====
* Центры кластеров рассчитываются по следующей формуле: <math>c_{j} = {{\sum_{i = 1}^{n}{u_{i,j}^m} * x_{i}} \over {\sum_{i = 1}^{n}{u_{i,j}^m}}}</math>, где <math>u_{i,j}</math> — коэффициент принадлежности <math>x_{i}</math> вектора к кластеру <math>c_{j}</math>.

* Евклидово расстояние от вектора <math>x_{i}</math> до центра кластера <math>c_{j}</math> рассчитывается по формуле: <math>\left\Vert{x_{i}-c_{j}}\right\|^2</math>

* Коэффициент принадлежности рассчитывается по формуле: <math>u_{i,j} = {1 \over \sum_{k = 1}^{C}{({\left\Vert{x_{i}-c_{j}}\right\| \over \left\Vert{x_{i}-c_{k}}\right\|})}^{2 \over m-1}}</math>

* Решающая функция рассчитывается по формуле: <math>\max_{i,j}(|u_{i,j}^{(k)} - u_{i,j}^{(k-1)}|)</math>, где <math>k</math> - номер итерации алгоритма

=== Вычислительное ядро алгоритма ===

Из вышесказанного следует, что ядром алгоритма является вычисление нового центра кластеров, для каждого входного вектора вычисление Евклидова расстояния до центров кластеров, а также коэффициент принадлежности и вычисления решающей функции.

=== Макроструктура алгоритма ===

=== Схема реализации последовательного алгоритма ===

Схему реализации последовательного алгоритма можно описать на C++ следующим образом:

<source lang="C++">

FCM (X[], C[], m, eps){
float deside = 0;
float newDeside = 0;
generateMembershipDegree(); //заполняет uPrev[][] случайными нормрованными коэффициентами
while (true){
newDeside = deside;

//вычисление центров кластеров
for (int j=0; j<C; j++){ //для каждого кластера
float numerator = 0;
float denumerator = 0;
for (int i=0; i<X; i++){ //для каждого вектора
numerator+=pow(u[i][j], m) * x[i];
denumerator+=pow(u[i][j], m);
}
c[j] = numerator / denumerator;
}

//вычисление коэффициентов u[][]
for (int i=0; i<X; i++) //для каждого вектора
for (int j=0; j<C; j++){ //для каждого кластера
sum = 0;
for (int k=0; k<C; k++)
sum+= pow( dist(x[i], c[j]) / dist(x[i], c[k]), 2/(m-1));
u[i][j] = 1/sum
}

//определения максимального различия между u[][] и uPrev[][]
float max = 0;
for (int i=0; i<X; i++) //для каждого вектора
for (int j=0; j<C; j++){ //для каждого кластера
if (abs(uPrev[i][j]-u[i][j])>max)
max = abs(uPrev[i][j]-u[i][j]);

if (eps <= max)
for (int i=0; i<X; i++) //для каждого вектора
for (int j=0; j<C; j++){ //для каждого кластера
uPrev[i][j]=u[i][j];
else
break;

}
return u;
}
</source>

=== Последовательная сложность алгоритма ===

Последовательная сложность всего алгоритма складывается из сложности операций на каждой итерации умноженную на количество итераций. Так как в данном алгоритме количество итераций не является фиксированным и зависит от:
* параметра <math>\varepsilon</math>
* набора входных векторов <math>x</math>
* выбора начальных коэффициентов <math>u</math>
то в данном пункте будет приведена сложность одной итерации относительно количества входных векторов.
Как видно из предыдущего пункта, для вычисления центров кластеров требуется <math>O(2*C*N)</math> операций, для определения коэффициентов <math>u</math> - <math>O(C^2*N*D)</math> операций, а для вычисления решающей функции - <math>O(2*C*N)</math> операций, где <math>N</math> - число входных векторов, <math>C</math> - количество кластеров, а <math>D</math> - количество операций, требуемых для вычисления Евклидова расстояния между вектором и центром кластера.

Таким образом итоговая сложность одной итерации составляет <math>O(C^2*N*D)</math>.

=== Информационный граф ===

=== Ресурс параллелизма алгоритма ===

=== Входные и выходные данные алгоритма ===

==== Входные данные алгоритма ====
* <math>x_{i}</math> - набор входных векторов
* <math>C</math> - количество кластеров
* <math>m</math> - коэффициент неопределённости
* <math>\varepsilon > 0</math> - коэффициент, определяющий точность алгоритма.

==== Выходные данные алгоритма ====
* <math>u</math> - матрица принадлежности векторов кластерам

=== Свойства алгоритма ===

== Литература ==

<references \>

Участник:Demon smd/Нечеткий алгоритм С средних

2016-09-30T16:25:40Z

Marina abramenkova:

{{algorithm
| name = Нечеткий алгоритм C средних (Fuzzy C-means)
| serial_complexity = <math>O(C^2*N*D*IterNumber)</math>
| pf_height = <math>-</math>
| pf_width = <math>-</math>
| input_data = <math>-</math>
| output_data = <math>-</math>
}}

Авторы описания алгоритма: [[Участник:Demon smd|Д.А.Гуськов]] [[Участник:marina abramenkova|М.А.Абраменкова]]

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===
Нечёткий алгоритм кластеризации С-средних был разработан (для случая m=2) J.C. Dunn в 1973 г.
<ref>Dunn, J. C. (1973-01-01). "A Fuzzy Relative of the ISODATA Process and Its Use in Detecting Compact Well-Separated Clusters". Journal of Cybernetics. 3 (3): 32–57. doi:10.1080/01969727308546046. ISSN 0022-0280.</ref>
и усовершенствован (для случая m>1)
J.C. Bezdek в 1981 г. <ref>Bezdek, James C. (1981). Pattern Recognition with Fuzzy Objective Function Algorithms. ISBN 0-306-40671-3.</ref>
. В отличие от алгоритма c-means Данный метод кластеризации предполагает, что входные данные могут принадлежать более, чем одному кластеру одновременно.
Алгоритм получает на вход набор кластеризируемых векторов, количество кластеров, коэффициент неопределённости m и коэффициент <math>\varepsilon > 0</math>, определяющий точность алгоритма. На выходе алгоритма получаем матрицу вероятностей принадлежности каждого входного вектора каждому кластеру.

Нечеткий алгоритм С средних для каждого вектора определяет случайным образом значения принадлежности вектора к каждому кластеру и запускает итерационный процесс, на каждой итерации которого происходит:

1) Расчёт центров кластеров.

2) Расчёт Евклидова расстояния от каждого вектора до центра каждого кластера

3) Расчёт и нормализация коэффициентов принадлежности векторов кластерам

4) Расчёт значения решающей функции и сравнение этого значения со значением решающей функции на предшествующей итерации.Если их разница меньше установленного значения, то алгоритм прекращает работу. Решающая функция возвращает сумму всех Евклидовых расстояний каждого объекта к каждому центру кластера умноженному на коэффициент принадлежности

=== Математическое описание алгоритма ===
Нечеткий алгоритм С средних минимизирует величину:
:<math>
\begin{align}
J_{m} = \sum_{i = 1}^{N}\sum_{j = 1}^{C}u_{i,j}^m\left\Vert{x_{i}-c_{j}}\right\|^2 & & , & & 1 \le m \le \infty & ; \\
\end{align}
</math>

где m - это действительное число не меньше единицы, <math>u_{i,j}</math> - коэффициент принадлежности вектора <math>x_{i}</math> к кластеру <math>c_{j}</math>, <math>x_{i}</math> - <math>i</math>-ый компонент <math>N</math>-мерного вектора <math>x</math>, <math>c_{j}</math>
- центр <math>j</math>-ого кластера, а <math>\left\Vert{*}\right\|</math> - это любая норма, определяющая расстояние от вектора до центра кластера.
Нечёткое разбиение входных данных на кластеры производится итеративной оптимизацией вышеуказанной функции с обновлением коэффициента принадлежности <math>u_{i,j}</math> и переопределением центра кластера <math>c_{j}</math> на каждой итерации алгоритма.

==== Вычисляемые данные на каждой итерации ====
* Центры кластеров рассчитываются по следующей формуле: <math>c_{j} = {{\sum_{i = 1}^{n}{u_{i,j}^m} * x_{i}} \over {\sum_{i = 1}^{n}{u_{i,j}^m}}}</math>, где <math>u_{i,j}</math> — коэффициент принадлежности <math>x_{i}</math> вектора к кластеру <math>c_{j}</math>.

* Евклидово расстояние от вектора <math>x_{i}</math> до центра кластера <math>c_{j}</math> рассчитывается по формуле: <math>\left\Vert{x_{i}-c_{j}}\right\|^2</math>

* Коэффициент принадлежности рассчитывается по формуле: <math>u_{i,j} = {1 \over \sum_{k = 1}^{C}{({\left\Vert{x_{i}-c_{j}}\right\| \over \left\Vert{x_{i}-c_{k}}\right\|})}^{2 \over m-1}}</math>

* Нормализация всех коэффициентов принадлежности объекта производится по формуле: <math>u_{i,j} = {u_{i,j} \over \sum_{j = 1}^{C}{u_{i,j}}} </math>

* Решающая функция рассчитывается по формуле: <math>\max_{i,j}(|u_{i,j}^{(k)} - u_{i,j}^{(k-1)}|)</math>, где <math>k</math> - номер итерации алгоритма

=== Вычислительное ядро алгоритма ===

Из вышесказанного следует, что ядром алгоритма является вычисление нового центра кластеров, для каждого входного вектора вычисление Евклидова расстояния до центров кластеров, а также коэффициент принадлежности и вычисления решающей функции.

=== Макроструктура алгоритма ===

=== Схема реализации последовательного алгоритма ===

Схему реализации последовательного алгоритма можно описать на C++ следующим образом:

<source lang="C++">

FCM (X[], C[], m, eps){
float deside = 0;
float newDeside = 0;
generateMembershipDegree(); //заполняет uPrev[][] случайными нормрованными коэффициентами
while (true){
newDeside = deside;

//вычисление центров кластеров
for (int j=0; j<C; j++){ //для каждого кластера
float numerator = 0;
float denumerator = 0;
for (int i=0; i<X; i++){ //для каждого вектора
numerator+=pow(u[i][j], m) * x[i];
denumerator+=pow(u[i][j], m);
}
c[j] = numerator / denumerator;
}

//вычисление коэффициентов u[][]
for (int i=0; i<X; i++) //для каждого вектора
for (int j=0; j<C; j++){ //для каждого кластера
sum = 0;
for (int k=0; k<C; k++)
sum+= pow( dist(x[i], c[j]) / dist(x[i], c[k]), 2/(m-1));
u[i][j] = 1/sum
}

//определения максимального различия между u[][] и uPrev[][]
float max = 0;
for (int i=0; i<X; i++) //для каждого вектора
for (int j=0; j<C; j++){ //для каждого кластера
if (abs(uPrev[i][j]-u[i][j])>max)
max = abs(uPrev[i][j]-u[i][j]);

if (eps <= max)
for (int i=0; i<X; i++) //для каждого вектора
for (int j=0; j<C; j++){ //для каждого кластера
uPrev[i][j]=u[i][j];
else
break;

}
return u;
}
</source>

=== Последовательная сложность алгоритма ===

Последовательная сложность всего алгоритма складывается из сложности операций на каждой итерации умноженную на количество итераций. Так как в данном алгоритме количество итераций не является фиксированным и зависит от:
* параметра <math>\varepsilon</math>
* набора входных векторов <math>x</math>
* выбора начальных коэффициентов <math>u</math>
то в данном пункте будет приведена сложность одной итерации относительно количества входных векторов.
Как видно из предыдущего пункта, для вычисления центров кластеров требуется <math>O(2*C*N)</math> операций, для определения коэффициентов <math>u</math> - <math>O(C^2*N*D)</math> операций, а для вычисления решающей функции - <math>O(2*C*N)</math> операций, где <math>N</math> - число входных векторов, <math>C</math> - количество кластеров, а <math>D</math> - количество операций, требуемых для вычисления Евклидова расстояния между вектором и центром кластера.

Таким образом итоговая сложность одной итерации составляет <math>O(C^2*N*D)</math>.

=== Информационный граф ===

=== Ресурс параллелизма алгоритма ===

=== Входные и выходные данные алгоритма ===

==== Входные данные алгоритма ====
* <math>x_{i}</math> - набор входных векторов
* <math>C</math> - количество кластеров
* <math>m</math> - коэффициент неопределённости
* <math>\varepsilon > 0</math> - коэффициент, определяющий точность алгоритма.

==== Выходные данные алгоритма ====
* <math>u</math> - матрица принадлежности векторов кластерам

=== Свойства алгоритма ===

== Литература ==

<references \>

Участник:Demon smd/Нечеткий алгоритм С средних

2016-09-30T16:20:56Z

Marina abramenkova: /* Последовательная сложность алгоритма */

{{algorithm
| name = Нечеткий алгоритм C средних (Fuzzy C-means)
| serial_complexity = <math>-</math>
| pf_height = <math>-</math>
| pf_width = <math>-</math>
| input_data = <math>-</math>
| output_data = <math>-</math>
}}

Авторы описания алгоритма: [[Участник:Demon smd|Д.А.Гуськов]] [[Участник:marina abramenkova|М.А.Абраменкова]]

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===
Нечёткий алгоритм кластеризации С-средних был разработан (для случая m=2) J.C. Dunn в 1973 г.
<ref>Dunn, J. C. (1973-01-01). "A Fuzzy Relative of the ISODATA Process and Its Use in Detecting Compact Well-Separated Clusters". Journal of Cybernetics. 3 (3): 32–57. doi:10.1080/01969727308546046. ISSN 0022-0280.</ref>
и усовершенствован (для случая m>1)
J.C. Bezdek в 1981 г. <ref>Bezdek, James C. (1981). Pattern Recognition with Fuzzy Objective Function Algorithms. ISBN 0-306-40671-3.</ref>
. В отличие от алгоритма c-means Данный метод кластеризации предполагает, что входные данные могут принадлежать более, чем одному кластеру одновременно.
Алгоритм получает на вход набор кластеризируемых векторов, количество кластеров, коэффициент неопределённости m и коэффициент <math>\varepsilon > 0</math>, определяющий точность алгоритма. На выходе алгоритма получаем матрицу вероятностей принадлежности каждого входного вектора каждому кластеру.

Нечеткий алгоритм С средних для каждого вектора определяет случайным образом значения принадлежности вектора к каждому кластеру и запускает итерационный процесс, на каждой итерации которого происходит:

1) Расчёт центров кластеров.

2) Расчёт Евклидова расстояния от каждого вектора до центра каждого кластера

3) Расчёт и нормализация коэффициентов принадлежности векторов кластерам

4) Расчёт значения решающей функции и сравнение этого значения со значением решающей функции на предшествующей итерации.Если их разница меньше установленного значения, то алгоритм прекращает работу. Решающая функция возвращает сумму всех Евклидовых расстояний каждого объекта к каждому центру кластера умноженному на коэффициент принадлежности

=== Математическое описание алгоритма ===
Нечеткий алгоритм С средних минимизирует величину:
:<math>
\begin{align}
J_{m} = \sum_{i = 1}^{N}\sum_{j = 1}^{C}u_{i,j}^m\left\Vert{x_{i}-c_{j}}\right\|^2 & & , & & 1 \le m \le \infty & ; \\
\end{align}
</math>

где m - это действительное число не меньше единицы, <math>u_{i,j}</math> - коэффициент принадлежности вектора <math>x_{i}</math> к кластеру <math>c_{j}</math>, <math>x_{i}</math> - <math>i</math>-ый компонент <math>N</math>-мерного вектора <math>x</math>, <math>c_{j}</math>
- центр <math>j</math>-ого кластера, а <math>\left\Vert{*}\right\|</math> - это любая норма, определяющая расстояние от вектора до центра кластера.
Нечёткое разбиение входных данных на кластеры производится итеративной оптимизацией вышеуказанной функции с обновлением коэффициента принадлежности <math>u_{i,j}</math> и переопределением центра кластера <math>c_{j}</math> на каждой итерации алгоритма.

==== Вычисляемые данные на каждой итерации ====
* Центры кластеров рассчитываются по следующей формуле: <math>c_{j} = {{\sum_{i = 1}^{n}{u_{i,j}^m} * x_{i}} \over {\sum_{i = 1}^{n}{u_{i,j}^m}}}</math>, где <math>u_{i,j}</math> — коэффициент принадлежности <math>x_{i}</math> вектора к кластеру <math>c_{j}</math>.

* Евклидово расстояние от вектора <math>x_{i}</math> до центра кластера <math>c_{j}</math> рассчитывается по формуле: <math>\left\Vert{x_{i}-c_{j}}\right\|^2</math>

* Коэффициент принадлежности рассчитывается по формуле: <math>u_{i,j} = {1 \over \sum_{k = 1}^{C}{({\left\Vert{x_{i}-c_{j}}\right\| \over \left\Vert{x_{i}-c_{k}}\right\|})}^{2 \over m-1}}</math>

* Нормализация всех коэффициентов принадлежности объекта производится по формуле: <math>u_{i,j} = {u_{i,j} \over \sum_{j = 1}^{C}{u_{i,j}}} </math>

* Решающая функция рассчитывается по формуле: <math>\max_{i,j}(|u_{i,j}^{(k)} - u_{i,j}^{(k-1)}|)</math>, где <math>k</math> - номер итерации алгоритма

=== Вычислительное ядро алгоритма ===

Из вышесказанного следует, что ядром алгоритма является вычисление нового центра кластеров, для каждого входного вектора вычисление Евклидова расстояния до центров кластеров, а также коэффициент принадлежности и вычисления решающей функции.

=== Макроструктура алгоритма ===

=== Схема реализации последовательного алгоритма ===

Схему реализации последовательного алгоритма можно описать на C++ следующим образом:

<source lang="C++">

FCM (X[], C[], m, eps){
float deside = 0;
float newDeside = 0;
generateMembershipDegree(); //заполняет uPrev[][] случайными нормрованными коэффициентами
while (true){
newDeside = deside;

//вычисление центров кластеров
for (int j=0; j<C; j++){ //для каждого кластера
float numerator = 0;
float denumerator = 0;
for (int i=0; i<X; i++){ //для каждого вектора
numerator+=pow(u[i][j], m) * x[i];
denumerator+=pow(u[i][j], m);
}
c[j] = numerator / denumerator;
}

//вычисление коэффициентов u[][]
for (int i=0; i<X; i++) //для каждого вектора
for (int j=0; j<C; j++){ //для каждого кластера
sum = 0;
for (int k=0; k<C; k++)
sum+= pow( dist(x[i], c[j]) / dist(x[i], c[k]), 2/(m-1));
u[i][j] = 1/sum
}

//определения максимального различия между u[][] и uPrev[][]
float max = 0;
for (int i=0; i<X; i++) //для каждого вектора
for (int j=0; j<C; j++){ //для каждого кластера
if (abs(uPrev[i][j]-u[i][j])>max)
max = abs(uPrev[i][j]-u[i][j]);

if (eps <= max)
for (int i=0; i<X; i++) //для каждого вектора
for (int j=0; j<C; j++){ //для каждого кластера
uPrev[i][j]=u[i][j];
else
break;

}
return u;
}
</source>

=== Последовательная сложность алгоритма ===

Последовательная сложность всего алгоритма складывается из сложности операций на каждой итерации умноженную на количество итераций. Так как в данном алгоритме количество итераций не является фиксированным и зависит от:
* параметра <math>\varepsilon</math>
* набора входных векторов <math>x</math>
* выбора начальных коэффициентов <math>u</math>
то в данном пункте будет приведена сложность одной итерации относительно количества входных векторов.
Как видно из предыдущего пункта, для вычисления центров кластеров требуется <math>O(2*C*N)</math> операций, для определения коэффициентов <math>u</math> - <math>O(C^2*N*D)</math> операций, а для вычисления решающей функции - <math>O(2*C*N)</math> операций, где <math>N</math> - число входных векторов, <math>C</math> - количество кластеров, а <math>D</math> - количество операций, требуемых для вычисления Евклидова расстояния между вектором и центром кластера.

Таким образом итоговая сложность одной итерации составляет <math>O(C^2*N*D)</math>.

=== Информационный граф ===

=== Ресурс параллелизма алгоритма ===

=== Входные и выходные данные алгоритма ===

==== Входные данные алгоритма ====
* <math>x_{i}</math> - набор входных векторов
* <math>C</math> - количество кластеров
* <math>m</math> - коэффициент неопределённости
* <math>\varepsilon > 0</math> - коэффициент, определяющий точность алгоритма.

==== Выходные данные алгоритма ====
* <math>u</math> - матрица принадлежности векторов кластерам

=== Свойства алгоритма ===

== Литература ==

<references \>

Участник:Demon smd/Нечеткий алгоритм С средних

2016-09-30T16:20:39Z

Marina abramenkova: /* Последовательная сложность алгоритма */

{{algorithm
| name = Нечеткий алгоритм C средних (Fuzzy C-means)
| serial_complexity = <math>-</math>
| pf_height = <math>-</math>
| pf_width = <math>-</math>
| input_data = <math>-</math>
| output_data = <math>-</math>
}}

Авторы описания алгоритма: [[Участник:Demon smd|Д.А.Гуськов]] [[Участник:marina abramenkova|М.А.Абраменкова]]

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===
Нечёткий алгоритм кластеризации С-средних был разработан (для случая m=2) J.C. Dunn в 1973 г.
<ref>Dunn, J. C. (1973-01-01). "A Fuzzy Relative of the ISODATA Process and Its Use in Detecting Compact Well-Separated Clusters". Journal of Cybernetics. 3 (3): 32–57. doi:10.1080/01969727308546046. ISSN 0022-0280.</ref>
и усовершенствован (для случая m>1)
J.C. Bezdek в 1981 г. <ref>Bezdek, James C. (1981). Pattern Recognition with Fuzzy Objective Function Algorithms. ISBN 0-306-40671-3.</ref>
. В отличие от алгоритма c-means Данный метод кластеризации предполагает, что входные данные могут принадлежать более, чем одному кластеру одновременно.
Алгоритм получает на вход набор кластеризируемых векторов, количество кластеров, коэффициент неопределённости m и коэффициент <math>\varepsilon > 0</math>, определяющий точность алгоритма. На выходе алгоритма получаем матрицу вероятностей принадлежности каждого входного вектора каждому кластеру.

Нечеткий алгоритм С средних для каждого вектора определяет случайным образом значения принадлежности вектора к каждому кластеру и запускает итерационный процесс, на каждой итерации которого происходит:

1) Расчёт центров кластеров.

2) Расчёт Евклидова расстояния от каждого вектора до центра каждого кластера

3) Расчёт и нормализация коэффициентов принадлежности векторов кластерам

4) Расчёт значения решающей функции и сравнение этого значения со значением решающей функции на предшествующей итерации.Если их разница меньше установленного значения, то алгоритм прекращает работу. Решающая функция возвращает сумму всех Евклидовых расстояний каждого объекта к каждому центру кластера умноженному на коэффициент принадлежности

=== Математическое описание алгоритма ===
Нечеткий алгоритм С средних минимизирует величину:
:<math>
\begin{align}
J_{m} = \sum_{i = 1}^{N}\sum_{j = 1}^{C}u_{i,j}^m\left\Vert{x_{i}-c_{j}}\right\|^2 & & , & & 1 \le m \le \infty & ; \\
\end{align}
</math>

где m - это действительное число не меньше единицы, <math>u_{i,j}</math> - коэффициент принадлежности вектора <math>x_{i}</math> к кластеру <math>c_{j}</math>, <math>x_{i}</math> - <math>i</math>-ый компонент <math>N</math>-мерного вектора <math>x</math>, <math>c_{j}</math>
- центр <math>j</math>-ого кластера, а <math>\left\Vert{*}\right\|</math> - это любая норма, определяющая расстояние от вектора до центра кластера.
Нечёткое разбиение входных данных на кластеры производится итеративной оптимизацией вышеуказанной функции с обновлением коэффициента принадлежности <math>u_{i,j}</math> и переопределением центра кластера <math>c_{j}</math> на каждой итерации алгоритма.

==== Вычисляемые данные на каждой итерации ====
* Центры кластеров рассчитываются по следующей формуле: <math>c_{j} = {{\sum_{i = 1}^{n}{u_{i,j}^m} * x_{i}} \over {\sum_{i = 1}^{n}{u_{i,j}^m}}}</math>, где <math>u_{i,j}</math> — коэффициент принадлежности <math>x_{i}</math> вектора к кластеру <math>c_{j}</math>.

* Евклидово расстояние от вектора <math>x_{i}</math> до центра кластера <math>c_{j}</math> рассчитывается по формуле: <math>\left\Vert{x_{i}-c_{j}}\right\|^2</math>

* Коэффициент принадлежности рассчитывается по формуле: <math>u_{i,j} = {1 \over \sum_{k = 1}^{C}{({\left\Vert{x_{i}-c_{j}}\right\| \over \left\Vert{x_{i}-c_{k}}\right\|})}^{2 \over m-1}}</math>

* Нормализация всех коэффициентов принадлежности объекта производится по формуле: <math>u_{i,j} = {u_{i,j} \over \sum_{j = 1}^{C}{u_{i,j}}} </math>

* Решающая функция рассчитывается по формуле: <math>\max_{i,j}(|u_{i,j}^{(k)} - u_{i,j}^{(k-1)}|)</math>, где <math>k</math> - номер итерации алгоритма

=== Вычислительное ядро алгоритма ===

Из вышесказанного следует, что ядром алгоритма является вычисление нового центра кластеров, для каждого входного вектора вычисление Евклидова расстояния до центров кластеров, а также коэффициент принадлежности и вычисления решающей функции.

=== Макроструктура алгоритма ===

=== Схема реализации последовательного алгоритма ===

Схему реализации последовательного алгоритма можно описать на C++ следующим образом:

<source lang="C++">

FCM (X[], C[], m, eps){
float deside = 0;
float newDeside = 0;
generateMembershipDegree(); //заполняет uPrev[][] случайными нормрованными коэффициентами
while (true){
newDeside = deside;

//вычисление центров кластеров
for (int j=0; j<C; j++){ //для каждого кластера
float numerator = 0;
float denumerator = 0;
for (int i=0; i<X; i++){ //для каждого вектора
numerator+=pow(u[i][j], m) * x[i];
denumerator+=pow(u[i][j], m);
}
c[j] = numerator / denumerator;
}

//вычисление коэффициентов u[][]
for (int i=0; i<X; i++) //для каждого вектора
for (int j=0; j<C; j++){ //для каждого кластера
sum = 0;
for (int k=0; k<C; k++)
sum+= pow( dist(x[i], c[j]) / dist(x[i], c[k]), 2/(m-1));
u[i][j] = 1/sum
}

//определения максимального различия между u[][] и uPrev[][]
float max = 0;
for (int i=0; i<X; i++) //для каждого вектора
for (int j=0; j<C; j++){ //для каждого кластера
if (abs(uPrev[i][j]-u[i][j])>max)
max = abs(uPrev[i][j]-u[i][j]);

if (eps <= max)
for (int i=0; i<X; i++) //для каждого вектора
for (int j=0; j<C; j++){ //для каждого кластера
uPrev[i][j]=u[i][j];
else
break;

}
return u;
}
</source>

=== Последовательная сложность алгоритма ===

Последовательная сложность всего алгоритма складывается из сложности операций на каждой итерации умноженную на количество итераций. Так как в данном алгоритме количество итераций не является фиксированным и зависит от:
* параметра <math>\varepsilon</math>
* набора входных векторов <math>x</math>
* выбора начальных коэффициентов <math>u</math>
то в данном пункте будет приведена сложность одной итерации относительно количества входных векторов.
Как видно из предыдущего пункта, для вычисления центров кластеров требуется <math>O(2*C*N)</math> операций, для определения коэффициентов <math>u</math> - <math>O(C^2*N*D)</math> операций, а для вычисления решающей функции - <math>O(2*C*N)</math> операций, где <math>N</math> - число входных векторов, <math>C</math> - количество кластеров, а <math>D</math> - количество операций, требуемых для вычисления Евклидова расстояния между вектором и центром кластера.
Таким образом итоговая сложность одной итерации составляет <math>O(C^2*N*D)</math>.

=== Информационный граф ===

=== Ресурс параллелизма алгоритма ===

=== Входные и выходные данные алгоритма ===

==== Входные данные алгоритма ====
* <math>x_{i}</math> - набор входных векторов
* <math>C</math> - количество кластеров
* <math>m</math> - коэффициент неопределённости
* <math>\varepsilon > 0</math> - коэффициент, определяющий точность алгоритма.

==== Выходные данные алгоритма ====
* <math>u</math> - матрица принадлежности векторов кластерам

=== Свойства алгоритма ===

== Литература ==

<references \>

Участник:Demon smd/Нечеткий алгоритм С средних

2016-09-30T16:18:19Z

Marina abramenkova: /* Последовательная сложность алгоритма */

{{algorithm
| name = Нечеткий алгоритм C средних (Fuzzy C-means)
| serial_complexity = <math>-</math>
| pf_height = <math>-</math>
| pf_width = <math>-</math>
| input_data = <math>-</math>
| output_data = <math>-</math>
}}

Авторы описания алгоритма: [[Участник:Demon smd|Д.А.Гуськов]] [[Участник:marina abramenkova|М.А.Абраменкова]]

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===
Нечёткий алгоритм кластеризации С-средних был разработан (для случая m=2) J.C. Dunn в 1973 г.
<ref>Dunn, J. C. (1973-01-01). "A Fuzzy Relative of the ISODATA Process and Its Use in Detecting Compact Well-Separated Clusters". Journal of Cybernetics. 3 (3): 32–57. doi:10.1080/01969727308546046. ISSN 0022-0280.</ref>
и усовершенствован (для случая m>1)
J.C. Bezdek в 1981 г. <ref>Bezdek, James C. (1981). Pattern Recognition with Fuzzy Objective Function Algorithms. ISBN 0-306-40671-3.</ref>
. В отличие от алгоритма c-means Данный метод кластеризации предполагает, что входные данные могут принадлежать более, чем одному кластеру одновременно.
Алгоритм получает на вход набор кластеризируемых векторов, количество кластеров, коэффициент неопределённости m и коэффициент <math>\varepsilon > 0</math>, определяющий точность алгоритма. На выходе алгоритма получаем матрицу вероятностей принадлежности каждого входного вектора каждому кластеру.

Нечеткий алгоритм С средних для каждого вектора определяет случайным образом значения принадлежности вектора к каждому кластеру и запускает итерационный процесс, на каждой итерации которого происходит:

1) Расчёт центров кластеров.

2) Расчёт Евклидова расстояния от каждого вектора до центра каждого кластера

3) Расчёт и нормализация коэффициентов принадлежности векторов кластерам

4) Расчёт значения решающей функции и сравнение этого значения со значением решающей функции на предшествующей итерации.Если их разница меньше установленного значения, то алгоритм прекращает работу. Решающая функция возвращает сумму всех Евклидовых расстояний каждого объекта к каждому центру кластера умноженному на коэффициент принадлежности

=== Математическое описание алгоритма ===
Нечеткий алгоритм С средних минимизирует величину:
:<math>
\begin{align}
J_{m} = \sum_{i = 1}^{N}\sum_{j = 1}^{C}u_{i,j}^m\left\Vert{x_{i}-c_{j}}\right\|^2 & & , & & 1 \le m \le \infty & ; \\
\end{align}
</math>

где m - это действительное число не меньше единицы, <math>u_{i,j}</math> - коэффициент принадлежности вектора <math>x_{i}</math> к кластеру <math>c_{j}</math>, <math>x_{i}</math> - <math>i</math>-ый компонент <math>N</math>-мерного вектора <math>x</math>, <math>c_{j}</math>
- центр <math>j</math>-ого кластера, а <math>\left\Vert{*}\right\|</math> - это любая норма, определяющая расстояние от вектора до центра кластера.
Нечёткое разбиение входных данных на кластеры производится итеративной оптимизацией вышеуказанной функции с обновлением коэффициента принадлежности <math>u_{i,j}</math> и переопределением центра кластера <math>c_{j}</math> на каждой итерации алгоритма.

==== Вычисляемые данные на каждой итерации ====
* Центры кластеров рассчитываются по следующей формуле: <math>c_{j} = {{\sum_{i = 1}^{n}{u_{i,j}^m} * x_{i}} \over {\sum_{i = 1}^{n}{u_{i,j}^m}}}</math>, где <math>u_{i,j}</math> — коэффициент принадлежности <math>x_{i}</math> вектора к кластеру <math>c_{j}</math>.

* Евклидово расстояние от вектора <math>x_{i}</math> до центра кластера <math>c_{j}</math> рассчитывается по формуле: <math>\left\Vert{x_{i}-c_{j}}\right\|^2</math>

* Коэффициент принадлежности рассчитывается по формуле: <math>u_{i,j} = {1 \over \sum_{k = 1}^{C}{({\left\Vert{x_{i}-c_{j}}\right\| \over \left\Vert{x_{i}-c_{k}}\right\|})}^{2 \over m-1}}</math>

* Нормализация всех коэффициентов принадлежности объекта производится по формуле: <math>u_{i,j} = {u_{i,j} \over \sum_{j = 1}^{C}{u_{i,j}}} </math>

* Решающая функция рассчитывается по формуле: <math>\max_{i,j}(|u_{i,j}^{(k)} - u_{i,j}^{(k-1)}|)</math>, где <math>k</math> - номер итерации алгоритма

=== Вычислительное ядро алгоритма ===

Из вышесказанного следует, что ядром алгоритма является вычисление нового центра кластеров, для каждого входного вектора вычисление Евклидова расстояния до центров кластеров, а также коэффициент принадлежности и вычисления решающей функции.

=== Макроструктура алгоритма ===

=== Схема реализации последовательного алгоритма ===

Схему реализации последовательного алгоритма можно описать на C++ следующим образом:

<source lang="C++">

FCM (X[], C[], m, eps){
float deside = 0;
float newDeside = 0;
generateMembershipDegree(); //заполняет uPrev[][] случайными нормрованными коэффициентами
while (true){
newDeside = deside;

//вычисление центров кластеров
for (int j=0; j<C; j++){ //для каждого кластера
float numerator = 0;
float denumerator = 0;
for (int i=0; i<X; i++){ //для каждого вектора
numerator+=pow(u[i][j], m) * x[i];
denumerator+=pow(u[i][j], m);
}
c[j] = numerator / denumerator;
}

//вычисление коэффициентов u[][]
for (int i=0; i<X; i++) //для каждого вектора
for (int j=0; j<C; j++){ //для каждого кластера
sum = 0;
for (int k=0; k<C; k++)
sum+= pow( dist(x[i], c[j]) / dist(x[i], c[k]), 2/(m-1));
u[i][j] = 1/sum
}

//определения максимального различия между u[][] и uPrev[][]
float max = 0;
for (int i=0; i<X; i++) //для каждого вектора
for (int j=0; j<C; j++){ //для каждого кластера
if (abs(uPrev[i][j]-u[i][j])>max)
max = abs(uPrev[i][j]-u[i][j]);

if (eps <= max)
for (int i=0; i<X; i++) //для каждого вектора
for (int j=0; j<C; j++){ //для каждого кластера
uPrev[i][j]=u[i][j];
else
break;

}
return u;
}
</source>

=== Последовательная сложность алгоритма ===

Последовательная сложность всего алгоритма складывается из сложности операций на каждой итерации умноженную на количество итераций. Так как в данном алгоритме количество итераций не является фиксированным и зависит от:
* параметра <math>\varepsilon</math>
* набора входных векторов <math>x</math>
* выбора начальных коэффициентов <math>u</math>
то в данном пункте будет приведена сложность одной итерации относительно количества входных векторов.
Как видно из предыдущего пункта, для вычисления центров кластеров требуется <math>O(2*C*N)</math> операций, для определения коэффициентов <math>u</math> - <math>O(С^{2} * N * D)</math> операций, а для вычисления решающей функции - <math>O(2*C*N)</math> операций, где <math>N</math> - число входных векторов, <math>C</math> - количество кластеров, а <math>D</math> - количество операций, требуемых для вычисления Евклидова расстояния между вектором и центром кластера.
Таким образом итоговая сложность одной итерации составляет <math>O(С*N*D)</math>.

=== Информационный граф ===

=== Ресурс параллелизма алгоритма ===

=== Входные и выходные данные алгоритма ===

==== Входные данные алгоритма ====
* <math>x_{i}</math> - набор входных векторов
* <math>C</math> - количество кластеров
* <math>m</math> - коэффициент неопределённости
* <math>\varepsilon > 0</math> - коэффициент, определяющий точность алгоритма.

==== Выходные данные алгоритма ====
* <math>u</math> - матрица принадлежности векторов кластерам

=== Свойства алгоритма ===

== Литература ==

<references \>

Участник:Demon smd/Нечеткий алгоритм С средних

2016-09-30T16:17:44Z

Marina abramenkova: /* Последовательная сложность алгоритма */

{{algorithm
| name = Нечеткий алгоритм C средних (Fuzzy C-means)
| serial_complexity = <math>-</math>
| pf_height = <math>-</math>
| pf_width = <math>-</math>
| input_data = <math>-</math>
| output_data = <math>-</math>
}}

Авторы описания алгоритма: [[Участник:Demon smd|Д.А.Гуськов]] [[Участник:marina abramenkova|М.А.Абраменкова]]

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===
Нечёткий алгоритм кластеризации С-средних был разработан (для случая m=2) J.C. Dunn в 1973 г.
<ref>Dunn, J. C. (1973-01-01). "A Fuzzy Relative of the ISODATA Process and Its Use in Detecting Compact Well-Separated Clusters". Journal of Cybernetics. 3 (3): 32–57. doi:10.1080/01969727308546046. ISSN 0022-0280.</ref>
и усовершенствован (для случая m>1)
J.C. Bezdek в 1981 г. <ref>Bezdek, James C. (1981). Pattern Recognition with Fuzzy Objective Function Algorithms. ISBN 0-306-40671-3.</ref>
. В отличие от алгоритма c-means Данный метод кластеризации предполагает, что входные данные могут принадлежать более, чем одному кластеру одновременно.
Алгоритм получает на вход набор кластеризируемых векторов, количество кластеров, коэффициент неопределённости m и коэффициент <math>\varepsilon > 0</math>, определяющий точность алгоритма. На выходе алгоритма получаем матрицу вероятностей принадлежности каждого входного вектора каждому кластеру.

Нечеткий алгоритм С средних для каждого вектора определяет случайным образом значения принадлежности вектора к каждому кластеру и запускает итерационный процесс, на каждой итерации которого происходит:

1) Расчёт центров кластеров.

2) Расчёт Евклидова расстояния от каждого вектора до центра каждого кластера

3) Расчёт и нормализация коэффициентов принадлежности векторов кластерам

4) Расчёт значения решающей функции и сравнение этого значения со значением решающей функции на предшествующей итерации.Если их разница меньше установленного значения, то алгоритм прекращает работу. Решающая функция возвращает сумму всех Евклидовых расстояний каждого объекта к каждому центру кластера умноженному на коэффициент принадлежности

=== Математическое описание алгоритма ===
Нечеткий алгоритм С средних минимизирует величину:
:<math>
\begin{align}
J_{m} = \sum_{i = 1}^{N}\sum_{j = 1}^{C}u_{i,j}^m\left\Vert{x_{i}-c_{j}}\right\|^2 & & , & & 1 \le m \le \infty & ; \\
\end{align}
</math>

где m - это действительное число не меньше единицы, <math>u_{i,j}</math> - коэффициент принадлежности вектора <math>x_{i}</math> к кластеру <math>c_{j}</math>, <math>x_{i}</math> - <math>i</math>-ый компонент <math>N</math>-мерного вектора <math>x</math>, <math>c_{j}</math>
- центр <math>j</math>-ого кластера, а <math>\left\Vert{*}\right\|</math> - это любая норма, определяющая расстояние от вектора до центра кластера.
Нечёткое разбиение входных данных на кластеры производится итеративной оптимизацией вышеуказанной функции с обновлением коэффициента принадлежности <math>u_{i,j}</math> и переопределением центра кластера <math>c_{j}</math> на каждой итерации алгоритма.

==== Вычисляемые данные на каждой итерации ====
* Центры кластеров рассчитываются по следующей формуле: <math>c_{j} = {{\sum_{i = 1}^{n}{u_{i,j}^m} * x_{i}} \over {\sum_{i = 1}^{n}{u_{i,j}^m}}}</math>, где <math>u_{i,j}</math> — коэффициент принадлежности <math>x_{i}</math> вектора к кластеру <math>c_{j}</math>.

* Евклидово расстояние от вектора <math>x_{i}</math> до центра кластера <math>c_{j}</math> рассчитывается по формуле: <math>\left\Vert{x_{i}-c_{j}}\right\|^2</math>

* Коэффициент принадлежности рассчитывается по формуле: <math>u_{i,j} = {1 \over \sum_{k = 1}^{C}{({\left\Vert{x_{i}-c_{j}}\right\| \over \left\Vert{x_{i}-c_{k}}\right\|})}^{2 \over m-1}}</math>

* Нормализация всех коэффициентов принадлежности объекта производится по формуле: <math>u_{i,j} = {u_{i,j} \over \sum_{j = 1}^{C}{u_{i,j}}} </math>

* Решающая функция рассчитывается по формуле: <math>\max_{i,j}(|u_{i,j}^{(k)} - u_{i,j}^{(k-1)}|)</math>, где <math>k</math> - номер итерации алгоритма

=== Вычислительное ядро алгоритма ===

Из вышесказанного следует, что ядром алгоритма является вычисление нового центра кластеров, для каждого входного вектора вычисление Евклидова расстояния до центров кластеров, а также коэффициент принадлежности и вычисления решающей функции.

=== Макроструктура алгоритма ===

=== Схема реализации последовательного алгоритма ===

Схему реализации последовательного алгоритма можно описать на C++ следующим образом:

<source lang="C++">

FCM (X[], C[], m, eps){
float deside = 0;
float newDeside = 0;
generateMembershipDegree(); //заполняет uPrev[][] случайными нормрованными коэффициентами
while (true){
newDeside = deside;

//вычисление центров кластеров
for (int j=0; j<C; j++){ //для каждого кластера
float numerator = 0;
float denumerator = 0;
for (int i=0; i<X; i++){ //для каждого вектора
numerator+=pow(u[i][j], m) * x[i];
denumerator+=pow(u[i][j], m);
}
c[j] = numerator / denumerator;
}

//вычисление коэффициентов u[][]
for (int i=0; i<X; i++) //для каждого вектора
for (int j=0; j<C; j++){ //для каждого кластера
sum = 0;
for (int k=0; k<C; k++)
sum+= pow( dist(x[i], c[j]) / dist(x[i], c[k]), 2/(m-1));
u[i][j] = 1/sum
}

//определения максимального различия между u[][] и uPrev[][]
float max = 0;
for (int i=0; i<X; i++) //для каждого вектора
for (int j=0; j<C; j++){ //для каждого кластера
if (abs(uPrev[i][j]-u[i][j])>max)
max = abs(uPrev[i][j]-u[i][j]);

if (eps <= max)
for (int i=0; i<X; i++) //для каждого вектора
for (int j=0; j<C; j++){ //для каждого кластера
uPrev[i][j]=u[i][j];
else
break;

}
return u;
}
</source>

=== Последовательная сложность алгоритма ===

Последовательная сложность всего алгоритма складывается из сложности операций на каждой итерации умноженную на количество итераций. Так как в данном алгоритме количество итераций не является фиксированным и зависит от:
* параметра <math>\varepsilon</math>
* набора входных векторов <math>x</math>
* выбора начальных коэффициентов <math>u</math>
то в данном пункте будет приведена сложность одной итерации относительно количества входных векторов.
Как видно из предыдущего пункта, для вычисления центров кластеров требуется <math>O(2*C*N)</math> операций, для определения коэффициентов <math>u</math> - <math>O(С^{2} * N * D)</math> операций, а для вычисления решающей функции - <math>O(2*C*N)</math> операций, где <math>N</math> - число входных векторов, <math>C</math> - количество кластеров, а <math>D</math> - количество операций, требуемых для вычисления Евклидова расстояния между вектором и центром кластера.
Таким образом итоговая сложность одной итерации составляет <math>O(С^{2} * N * D)</math>.

=== Информационный граф ===

=== Ресурс параллелизма алгоритма ===

=== Входные и выходные данные алгоритма ===

==== Входные данные алгоритма ====
* <math>x_{i}</math> - набор входных векторов
* <math>C</math> - количество кластеров
* <math>m</math> - коэффициент неопределённости
* <math>\varepsilon > 0</math> - коэффициент, определяющий точность алгоритма.

==== Выходные данные алгоритма ====
* <math>u</math> - матрица принадлежности векторов кластерам

=== Свойства алгоритма ===

== Литература ==

<references \>

Участник:Demon smd/Нечеткий алгоритм С средних

2016-09-30T16:16:00Z

Marina abramenkova: /* Последовательная сложность алгоритма */

{{algorithm
| name = Нечеткий алгоритм C средних (Fuzzy C-means)
| serial_complexity = <math>-</math>
| pf_height = <math>-</math>
| pf_width = <math>-</math>
| input_data = <math>-</math>
| output_data = <math>-</math>
}}

Авторы описания алгоритма: [[Участник:Demon smd|Д.А.Гуськов]] [[Участник:marina abramenkova|М.А.Абраменкова]]

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===
Нечёткий алгоритм кластеризации С-средних был разработан (для случая m=2) J.C. Dunn в 1973 г.
<ref>Dunn, J. C. (1973-01-01). "A Fuzzy Relative of the ISODATA Process and Its Use in Detecting Compact Well-Separated Clusters". Journal of Cybernetics. 3 (3): 32–57. doi:10.1080/01969727308546046. ISSN 0022-0280.</ref>
и усовершенствован (для случая m>1)
J.C. Bezdek в 1981 г. <ref>Bezdek, James C. (1981). Pattern Recognition with Fuzzy Objective Function Algorithms. ISBN 0-306-40671-3.</ref>
. В отличие от алгоритма c-means Данный метод кластеризации предполагает, что входные данные могут принадлежать более, чем одному кластеру одновременно.
Алгоритм получает на вход набор кластеризируемых векторов, количество кластеров, коэффициент неопределённости m и коэффициент <math>\varepsilon > 0</math>, определяющий точность алгоритма. На выходе алгоритма получаем матрицу вероятностей принадлежности каждого входного вектора каждому кластеру.

Нечеткий алгоритм С средних для каждого вектора определяет случайным образом значения принадлежности вектора к каждому кластеру и запускает итерационный процесс, на каждой итерации которого происходит:

1) Расчёт центров кластеров.

2) Расчёт Евклидова расстояния от каждого вектора до центра каждого кластера

3) Расчёт и нормализация коэффициентов принадлежности векторов кластерам

4) Расчёт значения решающей функции и сравнение этого значения со значением решающей функции на предшествующей итерации.Если их разница меньше установленного значения, то алгоритм прекращает работу. Решающая функция возвращает сумму всех Евклидовых расстояний каждого объекта к каждому центру кластера умноженному на коэффициент принадлежности

=== Математическое описание алгоритма ===
Нечеткий алгоритм С средних минимизирует величину:
:<math>
\begin{align}
J_{m} = \sum_{i = 1}^{N}\sum_{j = 1}^{C}u_{i,j}^m\left\Vert{x_{i}-c_{j}}\right\|^2 & & , & & 1 \le m \le \infty & ; \\
\end{align}
</math>

где m - это действительное число не меньше единицы, <math>u_{i,j}</math> - коэффициент принадлежности вектора <math>x_{i}</math> к кластеру <math>c_{j}</math>, <math>x_{i}</math> - <math>i</math>-ый компонент <math>N</math>-мерного вектора <math>x</math>, <math>c_{j}</math>
- центр <math>j</math>-ого кластера, а <math>\left\Vert{*}\right\|</math> - это любая норма, определяющая расстояние от вектора до центра кластера.
Нечёткое разбиение входных данных на кластеры производится итеративной оптимизацией вышеуказанной функции с обновлением коэффициента принадлежности <math>u_{i,j}</math> и переопределением центра кластера <math>c_{j}</math> на каждой итерации алгоритма.

==== Вычисляемые данные на каждой итерации ====
* Центры кластеров рассчитываются по следующей формуле: <math>c_{j} = {{\sum_{i = 1}^{n}{u_{i,j}^m} * x_{i}} \over {\sum_{i = 1}^{n}{u_{i,j}^m}}}</math>, где <math>u_{i,j}</math> — коэффициент принадлежности <math>x_{i}</math> вектора к кластеру <math>c_{j}</math>.

* Евклидово расстояние от вектора <math>x_{i}</math> до центра кластера <math>c_{j}</math> рассчитывается по формуле: <math>\left\Vert{x_{i}-c_{j}}\right\|^2</math>

* Коэффициент принадлежности рассчитывается по формуле: <math>u_{i,j} = {1 \over \sum_{k = 1}^{C}{({\left\Vert{x_{i}-c_{j}}\right\| \over \left\Vert{x_{i}-c_{k}}\right\|})}^{2 \over m-1}}</math>

* Нормализация всех коэффициентов принадлежности объекта производится по формуле: <math>u_{i,j} = {u_{i,j} \over \sum_{j = 1}^{C}{u_{i,j}}} </math>

* Решающая функция рассчитывается по формуле: <math>\max_{i,j}(|u_{i,j}^{(k)} - u_{i,j}^{(k-1)}|)</math>, где <math>k</math> - номер итерации алгоритма

=== Вычислительное ядро алгоритма ===

Из вышесказанного следует, что ядром алгоритма является вычисление нового центра кластеров, для каждого входного вектора вычисление Евклидова расстояния до центров кластеров, а также коэффициент принадлежности и вычисления решающей функции.

=== Макроструктура алгоритма ===

=== Схема реализации последовательного алгоритма ===

Схему реализации последовательного алгоритма можно описать на C++ следующим образом:

<source lang="C++">

FCM (X[], C[], m, eps){
float deside = 0;
float newDeside = 0;
generateMembershipDegree(); //заполняет uPrev[][] случайными нормрованными коэффициентами
while (true){
newDeside = deside;

//вычисление центров кластеров
for (int j=0; j<C; j++){ //для каждого кластера
float numerator = 0;
float denumerator = 0;
for (int i=0; i<X; i++){ //для каждого вектора
numerator+=pow(u[i][j], m) * x[i];
denumerator+=pow(u[i][j], m);
}
c[j] = numerator / denumerator;
}

//вычисление коэффициентов u[][]
for (int i=0; i<X; i++) //для каждого вектора
for (int j=0; j<C; j++){ //для каждого кластера
sum = 0;
for (int k=0; k<C; k++)
sum+= pow( dist(x[i], c[j]) / dist(x[i], c[k]), 2/(m-1));
u[i][j] = 1/sum
}

//определения максимального различия между u[][] и uPrev[][]
float max = 0;
for (int i=0; i<X; i++) //для каждого вектора
for (int j=0; j<C; j++){ //для каждого кластера
if (abs(uPrev[i][j]-u[i][j])>max)
max = abs(uPrev[i][j]-u[i][j]);

if (eps <= max)
for (int i=0; i<X; i++) //для каждого вектора
for (int j=0; j<C; j++){ //для каждого кластера
uPrev[i][j]=u[i][j];
else
break;

}
return u;
}
</source>

=== Последовательная сложность алгоритма ===

Последовательная сложность всего алгоритма складывается из сложности операций на каждой итерации умноженную на количество итераций. Так как в данном алгоритме количество итераций не является фиксированным и зависит от:
* параметра <math>\varepsilon</math>
* набора входных векторов <math>x</math>
* выбора начальных коэффициентов <math>u</math>
то в данном пункте будет приведена сложность одной итерации относительно количества входных векторов.
Как видно из предыдущего пункта, для вычисления центров кластеров требуется <math>O(2*C*N)</math> операций, для определения коэффициентов <math>u</math> - <math>O( С^2*N*D )</math> операций, а для вычисления решающей функции - <math>O(2*C*N)</math> операций, где <math>N</math> - число входных векторов, <math>C</math> - количество кластеров, а <math>D</math> - количество операций, требуемых для вычисления Евклидова расстояния между вектором и центром кластера.
Таким образом итоговая сложность одной итерации составляет <math>O(С^{2}*N*D)</math>.

=== Информационный граф ===

=== Ресурс параллелизма алгоритма ===

=== Входные и выходные данные алгоритма ===

==== Входные данные алгоритма ====
* <math>x_{i}</math> - набор входных векторов
* <math>C</math> - количество кластеров
* <math>m</math> - коэффициент неопределённости
* <math>\varepsilon > 0</math> - коэффициент, определяющий точность алгоритма.

==== Выходные данные алгоритма ====
* <math>u</math> - матрица принадлежности векторов кластерам

=== Свойства алгоритма ===

== Литература ==

<references \>

Участник:Demon smd/Нечеткий алгоритм С средних

2016-09-30T16:14:39Z

Marina abramenkova: /* Последовательная сложность алгоритма */

{{algorithm
| name = Нечеткий алгоритм C средних (Fuzzy C-means)
| serial_complexity = <math>-</math>
| pf_height = <math>-</math>
| pf_width = <math>-</math>
| input_data = <math>-</math>
| output_data = <math>-</math>
}}

Авторы описания алгоритма: [[Участник:Demon smd|Д.А.Гуськов]] [[Участник:marina abramenkova|М.А.Абраменкова]]

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===
Нечёткий алгоритм кластеризации С-средних был разработан (для случая m=2) J.C. Dunn в 1973 г.
<ref>Dunn, J. C. (1973-01-01). "A Fuzzy Relative of the ISODATA Process and Its Use in Detecting Compact Well-Separated Clusters". Journal of Cybernetics. 3 (3): 32–57. doi:10.1080/01969727308546046. ISSN 0022-0280.</ref>
и усовершенствован (для случая m>1)
J.C. Bezdek в 1981 г. <ref>Bezdek, James C. (1981). Pattern Recognition with Fuzzy Objective Function Algorithms. ISBN 0-306-40671-3.</ref>
. В отличие от алгоритма c-means Данный метод кластеризации предполагает, что входные данные могут принадлежать более, чем одному кластеру одновременно.
Алгоритм получает на вход набор кластеризируемых векторов, количество кластеров, коэффициент неопределённости m и коэффициент <math>\varepsilon > 0</math>, определяющий точность алгоритма. На выходе алгоритма получаем матрицу вероятностей принадлежности каждого входного вектора каждому кластеру.

Нечеткий алгоритм С средних для каждого вектора определяет случайным образом значения принадлежности вектора к каждому кластеру и запускает итерационный процесс, на каждой итерации которого происходит:

1) Расчёт центров кластеров.

2) Расчёт Евклидова расстояния от каждого вектора до центра каждого кластера

3) Расчёт и нормализация коэффициентов принадлежности векторов кластерам

4) Расчёт значения решающей функции и сравнение этого значения со значением решающей функции на предшествующей итерации.Если их разница меньше установленного значения, то алгоритм прекращает работу. Решающая функция возвращает сумму всех Евклидовых расстояний каждого объекта к каждому центру кластера умноженному на коэффициент принадлежности

=== Математическое описание алгоритма ===
Нечеткий алгоритм С средних минимизирует величину:
:<math>
\begin{align}
J_{m} = \sum_{i = 1}^{N}\sum_{j = 1}^{C}u_{i,j}^m\left\Vert{x_{i}-c_{j}}\right\|^2 & & , & & 1 \le m \le \infty & ; \\
\end{align}
</math>

где m - это действительное число не меньше единицы, <math>u_{i,j}</math> - коэффициент принадлежности вектора <math>x_{i}</math> к кластеру <math>c_{j}</math>, <math>x_{i}</math> - <math>i</math>-ый компонент <math>N</math>-мерного вектора <math>x</math>, <math>c_{j}</math>
- центр <math>j</math>-ого кластера, а <math>\left\Vert{*}\right\|</math> - это любая норма, определяющая расстояние от вектора до центра кластера.
Нечёткое разбиение входных данных на кластеры производится итеративной оптимизацией вышеуказанной функции с обновлением коэффициента принадлежности <math>u_{i,j}</math> и переопределением центра кластера <math>c_{j}</math> на каждой итерации алгоритма.

==== Вычисляемые данные на каждой итерации ====
* Центры кластеров рассчитываются по следующей формуле: <math>c_{j} = {{\sum_{i = 1}^{n}{u_{i,j}^m} * x_{i}} \over {\sum_{i = 1}^{n}{u_{i,j}^m}}}</math>, где <math>u_{i,j}</math> — коэффициент принадлежности <math>x_{i}</math> вектора к кластеру <math>c_{j}</math>.

* Евклидово расстояние от вектора <math>x_{i}</math> до центра кластера <math>c_{j}</math> рассчитывается по формуле: <math>\left\Vert{x_{i}-c_{j}}\right\|^2</math>

* Коэффициент принадлежности рассчитывается по формуле: <math>u_{i,j} = {1 \over \sum_{k = 1}^{C}{({\left\Vert{x_{i}-c_{j}}\right\| \over \left\Vert{x_{i}-c_{k}}\right\|})}^{2 \over m-1}}</math>

* Нормализация всех коэффициентов принадлежности объекта производится по формуле: <math>u_{i,j} = {u_{i,j} \over \sum_{j = 1}^{C}{u_{i,j}}} </math>

* Решающая функция рассчитывается по формуле: <math>\max_{i,j}(|u_{i,j}^{(k)} - u_{i,j}^{(k-1)}|)</math>, где <math>k</math> - номер итерации алгоритма

=== Вычислительное ядро алгоритма ===

Из вышесказанного следует, что ядром алгоритма является вычисление нового центра кластеров, для каждого входного вектора вычисление Евклидова расстояния до центров кластеров, а также коэффициент принадлежности и вычисления решающей функции.

=== Макроструктура алгоритма ===

=== Схема реализации последовательного алгоритма ===

Схему реализации последовательного алгоритма можно описать на C++ следующим образом:

<source lang="C++">

FCM (X[], C[], m, eps){
float deside = 0;
float newDeside = 0;
generateMembershipDegree(); //заполняет uPrev[][] случайными нормрованными коэффициентами
while (true){
newDeside = deside;

//вычисление центров кластеров
for (int j=0; j<C; j++){ //для каждого кластера
float numerator = 0;
float denumerator = 0;
for (int i=0; i<X; i++){ //для каждого вектора
numerator+=pow(u[i][j], m) * x[i];
denumerator+=pow(u[i][j], m);
}
c[j] = numerator / denumerator;
}

//вычисление коэффициентов u[][]
for (int i=0; i<X; i++) //для каждого вектора
for (int j=0; j<C; j++){ //для каждого кластера
sum = 0;
for (int k=0; k<C; k++)
sum+= pow( dist(x[i], c[j]) / dist(x[i], c[k]), 2/(m-1));
u[i][j] = 1/sum
}

//определения максимального различия между u[][] и uPrev[][]
float max = 0;
for (int i=0; i<X; i++) //для каждого вектора
for (int j=0; j<C; j++){ //для каждого кластера
if (abs(uPrev[i][j]-u[i][j])>max)
max = abs(uPrev[i][j]-u[i][j]);

if (eps <= max)
for (int i=0; i<X; i++) //для каждого вектора
for (int j=0; j<C; j++){ //для каждого кластера
uPrev[i][j]=u[i][j];
else
break;

}
return u;
}
</source>

=== Последовательная сложность алгоритма ===

Последовательная сложность всего алгоритма складывается из сложности операций на каждой итерации умноженную на количество итераций. Так как в данном алгоритме количество итераций не является фиксированным и зависит от:
* параметра <math>\varepsilon</math>
* набора входных векторов <math>x</math>
* выбора начальных коэффициентов <math>u</math>
то в данном пункте будет приведена сложность одной итерации относительно количества входных векторов.
Как видно из предыдущего пункта, для вычисления центров кластеров требуется <math>O(2*C*N)</math> операций, для определения коэффициентов <math>u</math> - <math>O(С^{2}*N*D)</math> операций, а для вычисления решающей функции - <math>O(2*C*N)</math> операций, где <math>N</math> - число входных векторов, <math>C</math> - количество кластеров, а <math>D</math> - количество операций, требуемых для вычисления Евклидова расстояния между вектором и центром кластера.
Таким образом итоговая сложность одной итерации составляет <math>O(С^{2}*N*D)</math>.

=== Информационный граф ===

=== Ресурс параллелизма алгоритма ===

=== Входные и выходные данные алгоритма ===

==== Входные данные алгоритма ====
* <math>x_{i}</math> - набор входных векторов
* <math>C</math> - количество кластеров
* <math>m</math> - коэффициент неопределённости
* <math>\varepsilon > 0</math> - коэффициент, определяющий точность алгоритма.

==== Выходные данные алгоритма ====
* <math>u</math> - матрица принадлежности векторов кластерам

=== Свойства алгоритма ===

== Литература ==

<references \>

Участник:Demon smd/Нечеткий алгоритм С средних

2016-09-30T16:03:26Z

Marina abramenkova: /* Схема реализации последовательного алгоритма */

{{algorithm
| name = Нечеткий алгоритм C средних (Fuzzy C-means)
| serial_complexity = <math>-</math>
| pf_height = <math>-</math>
| pf_width = <math>-</math>
| input_data = <math>-</math>
| output_data = <math>-</math>
}}

Авторы описания алгоритма: [[Участник:Demon smd|Д.А.Гуськов]] [[Участник:marina abramenkova|М.А.Абраменкова]]

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===
Нечёткий алгоритм кластеризации С-средних был разработан (для случая m=2) J.C. Dunn в 1973 г.
<ref>Dunn, J. C. (1973-01-01). "A Fuzzy Relative of the ISODATA Process and Its Use in Detecting Compact Well-Separated Clusters". Journal of Cybernetics. 3 (3): 32–57. doi:10.1080/01969727308546046. ISSN 0022-0280.</ref>
и усовершенствован (для случая m>1)
J.C. Bezdek в 1981 г. <ref>Bezdek, James C. (1981). Pattern Recognition with Fuzzy Objective Function Algorithms. ISBN 0-306-40671-3.</ref>
. В отличие от алгоритма c-means Данный метод кластеризации предполагает, что входные данные могут принадлежать более, чем одному кластеру одновременно.
Алгоритм получает на вход набор кластеризируемых векторов, количество кластеров, коэффициент неопределённости m и коэффициент <math>\varepsilon > 0</math>, определяющий точность алгоритма. На выходе алгоритма получаем матрицу вероятностей принадлежности каждого входного вектора каждому кластеру.

Нечеткий алгоритм С средних для каждого вектора определяет случайным образом значения принадлежности вектора к каждому кластеру и запускает итерационный процесс, на каждой итерации которого происходит:

1) Расчёт центров кластеров.

2) Расчёт Евклидова расстояния от каждого вектора до центра каждого кластера

3) Расчёт и нормализация коэффициентов принадлежности векторов кластерам

4) Расчёт значения решающей функции и сравнение этого значения со значением решающей функции на предшествующей итерации.Если их разница меньше установленного значения, то алгоритм прекращает работу. Решающая функция возвращает сумму всех Евклидовых расстояний каждого объекта к каждому центру кластера умноженному на коэффициент принадлежности

=== Математическое описание алгоритма ===
Нечеткий алгоритм С средних минимизирует величину:
:<math>
\begin{align}
J_{m} = \sum_{i = 1}^{N}\sum_{j = 1}^{C}u_{i,j}^m\left\Vert{x_{i}-c_{j}}\right\|^2 & & , & & 1 \le m \le \infty & ; \\
\end{align}
</math>

где m - это действительное число не меньше единицы, <math>u_{i,j}</math> - коэффициент принадлежности вектора <math>x_{i}</math> к кластеру <math>c_{j}</math>, <math>x_{i}</math> - <math>i</math>-ый компонент <math>N</math>-мерного вектора <math>x</math>, <math>c_{j}</math>
- центр <math>j</math>-ого кластера, а <math>\left\Vert{*}\right\|</math> - это любая норма, определяющая расстояние от вектора до центра кластера.
Нечёткое разбиение входных данных на кластеры производится итеративной оптимизацией вышеуказанной функции с обновлением коэффициента принадлежности <math>u_{i,j}</math> и переопределением центра кластера <math>c_{j}</math> на каждой итерации алгоритма.

==== Вычисляемые данные на каждой итерации ====
* Центры кластеров рассчитываются по следующей формуле: <math>c_{j} = {{\sum_{i = 1}^{n}{u_{i,j}^m} * x_{i}} \over {\sum_{i = 1}^{n}{u_{i,j}^m}}}</math>, где <math>u_{i,j}</math> — коэффициент принадлежности <math>x_{i}</math> вектора к кластеру <math>c_{j}</math>.

* Евклидово расстояние от вектора <math>x_{i}</math> до центра кластера <math>c_{j}</math> рассчитывается по формуле: <math>\left\Vert{x_{i}-c_{j}}\right\|^2</math>

* Коэффициент принадлежности рассчитывается по формуле: <math>u_{i,j} = {1 \over \sum_{k = 1}^{C}{({\left\Vert{x_{i}-c_{j}}\right\| \over \left\Vert{x_{i}-c_{k}}\right\|})}^{2 \over m-1}}</math>

* Нормализация всех коэффициентов принадлежности объекта производится по формуле: <math>u_{i,j} = {u_{i,j} \over \sum_{j = 1}^{C}{u_{i,j}}} </math>

* Решающая функция рассчитывается по формуле: <math>\max_{i,j}(|u_{i,j}^{(k)} - u_{i,j}^{(k-1)}|)</math>, где <math>k</math> - номер итерации алгоритма

=== Вычислительное ядро алгоритма ===

Из вышесказанного следует, что ядром алгоритма является вычисление нового центра кластеров, для каждого входного вектора вычисление Евклидова расстояния до центров кластеров, а также коэффициент принадлежности и вычисления решающей функции.

=== Макроструктура алгоритма ===

=== Схема реализации последовательного алгоритма ===

Схему реализации последовательного алгоритма можно описать на C++ следующим образом:

<source lang="C++">

FCM (X[], C[], m, eps){
float deside = 0;
float newDeside = 0;
generateMembershipDegree(); //заполняет uPrev[][] случайными нормрованными коэффициентами
while (true){
newDeside = deside;

//вычисление центров кластеров
for (int j=0; j<C; j++){ //для каждого кластера
float numerator = 0;
float denumerator = 0;
for (int i=0; i<X; i++){ //для каждого вектора
numerator+=pow(u[i][j], m) * x[i];
denumerator+=pow(u[i][j], m);
}
c[j] = numerator / denumerator;
}

//вычисление коэффициентов u[][]
for (int i=0; i<X; i++) //для каждого вектора
for (int j=0; j<C; j++){ //для каждого кластера
sum = 0;
for (int k=0; k<C; k++)
sum+= pow( dist(x[i], c[j]) / dist(x[i], c[k]), 2/(m-1));
u[i][j] = 1/sum
}

//определения максимального различия между u[][] и uPrev[][]
float max = 0;
for (int i=0; i<X; i++) //для каждого вектора
for (int j=0; j<C; j++){ //для каждого кластера
if (abs(uPrev[i][j]-u[i][j])>max)
max = abs(uPrev[i][j]-u[i][j]);

if (eps <= max)
for (int i=0; i<X; i++) //для каждого вектора
for (int j=0; j<C; j++){ //для каждого кластера
uPrev[i][j]=u[i][j];
else
break;

}
return u;
}
</source>

=== Последовательная сложность алгоритма ===

Последовательная сложность всего алгоритма складывается из сложности операций на каждой итерации умноженную на количество итераций. Так как в данном алгоритме количество итераций не является фиксированным и зависит от:
* параметра <math>\varepsilon</math>
* набора входных векторов <math>x</math>
* выбора начальных коэффициентов <math>u</math>
то в данном пункте будет приведена сложность одной итерации относительно количества входных векторов.
Как видно из предыдущего пункта,

=== Информационный граф ===

=== Ресурс параллелизма алгоритма ===

=== Входные и выходные данные алгоритма ===

==== Входные данные алгоритма ====
* <math>x_{i}</math> - набор входных векторов
* <math>C</math> - количество кластеров
* <math>m</math> - коэффициент неопределённости
* <math>\varepsilon > 0</math> - коэффициент, определяющий точность алгоритма.

==== Выходные данные алгоритма ====
* <math>u</math> - матрица принадлежности векторов кластерам

=== Свойства алгоритма ===

== Литература ==

<references \>

Участник:Demon smd/Нечеткий алгоритм С средних

2016-09-30T15:57:41Z

Marina abramenkova: /* Последовательная сложность алгоритма */

{{algorithm
| name = Нечеткий алгоритм C средних (Fuzzy C-means)
| serial_complexity = <math>-</math>
| pf_height = <math>-</math>
| pf_width = <math>-</math>
| input_data = <math>-</math>
| output_data = <math>-</math>
}}

Авторы описания алгоритма: [[Участник:Demon smd|Д.А.Гуськов]] [[Участник:marina abramenkova|М.А.Абраменкова]]

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===
Нечёткий алгоритм кластеризации С-средних был разработан (для случая m=2) J.C. Dunn в 1973 г.
<ref>Dunn, J. C. (1973-01-01). "A Fuzzy Relative of the ISODATA Process and Its Use in Detecting Compact Well-Separated Clusters". Journal of Cybernetics. 3 (3): 32–57. doi:10.1080/01969727308546046. ISSN 0022-0280.</ref>
и усовершенствован (для случая m>1)
J.C. Bezdek в 1981 г. <ref>Bezdek, James C. (1981). Pattern Recognition with Fuzzy Objective Function Algorithms. ISBN 0-306-40671-3.</ref>
. В отличие от алгоритма c-means Данный метод кластеризации предполагает, что входные данные могут принадлежать более, чем одному кластеру одновременно.
Алгоритм получает на вход набор кластеризируемых векторов, количество кластеров, коэффициент неопределённости m и коэффициент <math>\varepsilon > 0</math>, определяющий точность алгоритма. На выходе алгоритма получаем матрицу вероятностей принадлежности каждого входного вектора каждому кластеру.

Нечеткий алгоритм С средних для каждого вектора определяет случайным образом значения принадлежности вектора к каждому кластеру и запускает итерационный процесс, на каждой итерации которого происходит:

1) Расчёт центров кластеров.

2) Расчёт Евклидова расстояния от каждого вектора до центра каждого кластера

3) Расчёт и нормализация коэффициентов принадлежности векторов кластерам

4) Расчёт значения решающей функции и сравнение этого значения со значением решающей функции на предшествующей итерации.Если их разница меньше установленного значения, то алгоритм прекращает работу. Решающая функция возвращает сумму всех Евклидовых расстояний каждого объекта к каждому центру кластера умноженному на коэффициент принадлежности

=== Математическое описание алгоритма ===
Нечеткий алгоритм С средних минимизирует величину:
:<math>
\begin{align}
J_{m} = \sum_{i = 1}^{N}\sum_{j = 1}^{C}u_{i,j}^m\left\Vert{x_{i}-c_{j}}\right\|^2 & & , & & 1 \le m \le \infty & ; \\
\end{align}
</math>

где m - это действительное число не меньше единицы, <math>u_{i,j}</math> - коэффициент принадлежности вектора <math>x_{i}</math> к кластеру <math>c_{j}</math>, <math>x_{i}</math> - <math>i</math>-ый компонент <math>N</math>-мерного вектора <math>x</math>, <math>c_{j}</math>
- центр <math>j</math>-ого кластера, а <math>\left\Vert{*}\right\|</math> - это любая норма, определяющая расстояние от вектора до центра кластера.
Нечёткое разбиение входных данных на кластеры производится итеративной оптимизацией вышеуказанной функции с обновлением коэффициента принадлежности <math>u_{i,j}</math> и переопределением центра кластера <math>c_{j}</math> на каждой итерации алгоритма.

==== Вычисляемые данные на каждой итерации ====
* Центры кластеров рассчитываются по следующей формуле: <math>c_{j} = {{\sum_{i = 1}^{n}{u_{i,j}^m} * x_{i}} \over {\sum_{i = 1}^{n}{u_{i,j}^m}}}</math>, где <math>u_{i,j}</math> — коэффициент принадлежности <math>x_{i}</math> вектора к кластеру <math>c_{j}</math>.

* Евклидово расстояние от вектора <math>x_{i}</math> до центра кластера <math>c_{j}</math> рассчитывается по формуле: <math>\left\Vert{x_{i}-c_{j}}\right\|^2</math>

* Коэффициент принадлежности рассчитывается по формуле: <math>u_{i,j} = {1 \over \sum_{k = 1}^{C}{({\left\Vert{x_{i}-c_{j}}\right\| \over \left\Vert{x_{i}-c_{k}}\right\|})}^{2 \over m-1}}</math>

* Нормализация всех коэффициентов принадлежности объекта производится по формуле: <math>u_{i,j} = {u_{i,j} \over \sum_{j = 1}^{C}{u_{i,j}}} </math>

* Решающая функция рассчитывается по формуле: <math>\max_{i,j}(|u_{i,j}^{(k)} - u_{i,j}^{(k-1)}|)</math>, где <math>k</math> - номер итерации алгоритма

=== Вычислительное ядро алгоритма ===

Из вышесказанного следует, что ядром алгоритма является вычисление нового центра кластеров, для каждого входного вектора вычисление Евклидова расстояния до центров кластеров, а также коэффициент принадлежности и вычисления решающей функции.

=== Макроструктура алгоритма ===

=== Схема реализации последовательного алгоритма ===

Схему реализации последовательного алгоритма можно описать на C++ следующим образом:

<source lang="C++">

FCM (X[], C[], m, eps){
float deside = 0;
float newDeside = 0;
generateMembershipDegree(); //заполняет uPrev[][] случайными нормрованными коэффициентами
while (true){
newDeside = deside;

for (int j=0; j<C; j++){ //для каждого кластера
float numerator = 0;
float denumerator = 0;
for (int i=0; i<X; i++){ //для каждого вектора
numerator+=pow(u[i][j], m) * x[i];
denumerator+=pow(u[i][j], m);
}
c[j] = numerator / denumerator;
}

for (int i=0; i<X; i++) //для каждого вектора
for (int j=0; j<C; j++){ //для каждого кластера
sum = 0;
for (int k=0; k<C; k++)
sum+= pow( dist(x[i], c[j]) / dist(x[i], c[k]), 2/(m-1));
u[i][j] = 1/sum
}

float max = 0;
for (int i=0; i<X; i++) //для каждого вектора
for (int j=0; j<C; j++){ //для каждого кластера
if (abs(uPrev[i][j]-u[i][j])>max)
max = abs(uPrev[i][j]-u[i][j]);

if (eps <= max)
for (int i=0; i<X; i++) //для каждого вектора
for (int j=0; j<C; j++){ //для каждого кластера
uPrev[i][j]=u[i][j];
else
break;

}
return u;
}
</source>

=== Последовательная сложность алгоритма ===

Последовательная сложность всего алгоритма складывается из сложности операций на каждой итерации умноженную на количество итераций. Так как в данном алгоритме количество итераций не является фиксированным и зависит от:
* параметра <math>\varepsilon</math>
* набора входных векторов <math>x</math>
* выбора начальных коэффициентов <math>u</math>
то в данном пункте будет приведена сложность одной итерации относительно количества входных векторов.
Как видно из предыдущего пункта,

=== Информационный граф ===

=== Ресурс параллелизма алгоритма ===

=== Входные и выходные данные алгоритма ===

==== Входные данные алгоритма ====
* <math>x_{i}</math> - набор входных векторов
* <math>C</math> - количество кластеров
* <math>m</math> - коэффициент неопределённости
* <math>\varepsilon > 0</math> - коэффициент, определяющий точность алгоритма.

==== Выходные данные алгоритма ====
* <math>u</math> - матрица принадлежности векторов кластерам

=== Свойства алгоритма ===

== Литература ==

<references \>