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

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

2016-12-18T21:13:47Z

Demon smd:

{{Assignment|Coctic}}

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

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

Последовательная сложность всего алгоритма складывается из сложности операций на каждой итерации умноженную на количество итераций.
Под операцией будем понимать выражение в языке с++ из пункта 1.5, находящееся в теле цикла (например, выражения "sum+= pow( dist(x[i], c[j]) / dist(x[i], c[k]), 2/(m-1));" или "uPrev[i][j]=u[i][j];" считаются за одну операцию). Так как при больших входных объёмах данных сложность алгоритма в большей степени зависит от количества входных данных, и незначительно зависит от сложности операций,то при оценке сложности алгоритма сложность выражений можно считать равной единице. Так как в данном алгоритме количество итераций не является фиксированным и зависит от:
* параметра <math>\varepsilon</math>
* набора входных векторов <math>x</math>
* выбора начальных коэффициентов <math>u</math>
то в данном пункте будет приведена сложность одной итерации относительно количества входных векторов.
Для вычисления коэффициентов u[][] на каждой итерации алгоритма требуется определить расстояние от векторов до центра кластера. Сложность данной операции зависит от размерности входных данных и определении нормы. В виду того, что для разных задач могут быть введены разные нормы, и сложность вычисления расстояний может варьироваться, то в данной статье будем считать, что сложность вычисления расстояния зависит линейно от размерности водных данных. В таком случае, для вычисления центров кластеров требуется <math>O(2*C*|X|)</math> операций, для определения коэффициентов <math>u</math> - <math>O(C^2*|X|*D)</math> операций, а для вычисления решающей функции - <math>O(2*C*|X|)</math> операций, где <math>|X|</math> - число входных векторов, а <math>C</math> - количество кластеров.

Таким образом итоговая сложность одной итерации составляет <math>O(C^2*|X|*D)</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-18T21:13:03Z

Demon smd:

{{Assignment|Coctic}}

{{algorithm
| name = Нечеткий алгоритм C средних (Fuzzy C-means)
| serial_complexity = <math>O(C^2*|X|*IterNumber)</math>
| pf_height = <math>O(\log_{2}C^4*|X|^3) * IterNumber</math>
| pf_width = <math>O(C^2*|X|*D)</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}
\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>

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

Последовательная сложность всего алгоритма складывается из сложности операций на каждой итерации умноженную на количество итераций.
Под операцией будем понимать выражение в языке с++ из пункта 1.5, находящееся в теле цикла (например, выражения "sum+= pow( dist(x[i], c[j]) / dist(x[i], c[k]), 2/(m-1));" или "uPrev[i][j]=u[i][j];" считаются за одну операцию). Так как при больших входных объёмах данных сложность алгоритма в большей степени зависит от количества входных данных, и незначительно зависит от сложности операций,то при оценке сложности алгоритма сложность выражений можно считать равной единице. Так как в данном алгоритме количество итераций не является фиксированным и зависит от:
* параметра <math>\varepsilon</math>
* набора входных векторов <math>x</math>
* выбора начальных коэффициентов <math>u</math>
то в данном пункте будет приведена сложность одной итерации относительно количества входных векторов.
Для вычисления коэффициентов u[][] на каждой итерации алгоритма требуется определить расстояние от векторов до центра кластера. Сложность данной операции зависит от размерности входных данных и определении нормы. В виду того, что для разных задач могут быть введены разные нормы, и сложность вычисления расстояний может варьироваться, то в данной статье будем считать, что сложность вычисления расстояния зависит линейно от размерности водных данных. В таком случае, для вычисления центров кластеров требуется <math>O(2*C*|X|)</math> операций, для определения коэффициентов <math>u</math> - <math>O(C^2*|X|*D)</math> операций, а для вычисления решающей функции - <math>O(2*C*|X|)</math> операций, где <math>|X|</math> - число входных векторов, а <math>C</math> - количество кластеров.

Таким образом итоговая сложность одной итерации составляет <math>O(C^2*|X|*D)</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-18T21:12:34Z

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

{{Assignment|Coctic}}

{{algorithm
| name = Нечеткий алгоритм C средних (Fuzzy C-means)
| serial_complexity = <math>O(C^2*|X|*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}
\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>

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

Последовательная сложность всего алгоритма складывается из сложности операций на каждой итерации умноженную на количество итераций.
Под операцией будем понимать выражение в языке с++ из пункта 1.5, находящееся в теле цикла (например, выражения "sum+= pow( dist(x[i], c[j]) / dist(x[i], c[k]), 2/(m-1));" или "uPrev[i][j]=u[i][j];" считаются за одну операцию). Так как при больших входных объёмах данных сложность алгоритма в большей степени зависит от количества входных данных, и незначительно зависит от сложности операций,то при оценке сложности алгоритма сложность выражений можно считать равной единице. Так как в данном алгоритме количество итераций не является фиксированным и зависит от:
* параметра <math>\varepsilon</math>
* набора входных векторов <math>x</math>
* выбора начальных коэффициентов <math>u</math>
то в данном пункте будет приведена сложность одной итерации относительно количества входных векторов.
Для вычисления коэффициентов u[][] на каждой итерации алгоритма требуется определить расстояние от векторов до центра кластера. Сложность данной операции зависит от размерности входных данных и определении нормы. В виду того, что для разных задач могут быть введены разные нормы, и сложность вычисления расстояний может варьироваться, то в данной статье будем считать, что сложность вычисления расстояния зависит линейно от размерности водных данных. В таком случае, для вычисления центров кластеров требуется <math>O(2*C*|X|)</math> операций, для определения коэффициентов <math>u</math> - <math>O(C^2*|X|*D)</math> операций, а для вычисления решающей функции - <math>O(2*C*|X|)</math> операций, где <math>|X|</math> - число входных векторов, а <math>C</math> - количество кластеров.

Таким образом итоговая сложность одной итерации составляет <math>O(C^2*|X|*D)</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-18T17:37:28Z

Demon smd:

{{Assignment|{{REVISIONUSER}}}}

{{algorithm
| name = Нечеткий алгоритм C средних (Fuzzy C-means)
| serial_complexity = <math>O(C^2*|X|*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}
\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>

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

Последовательная сложность всего алгоритма складывается из сложности операций на каждой итерации умноженную на количество итераций.
Под операцией будем понимать выражение в языке с++ из пункта 1.5, находящееся в теле цикла (например, выражения "sum+= pow( dist(x[i], c[j]) / dist(x[i], c[k]), 2/(m-1));" или "uPrev[i][j]=u[i][j];" считаются за одну операцию). Так как при больших входных объёмах данных сложность алгоритма в большей степени зависит от количества входных данных, и незначительно зависит от сложности операций,то при оценке сложности алгоритма сложность выражений можно считать равной единице. Так как в данном алгоритме количество итераций не является фиксированным и зависит от:
* параметра <math>\varepsilon</math>
* набора входных векторов <math>x</math>
* выбора начальных коэффициентов <math>u</math>
то в данном пункте будет приведена сложность одной итерации относительно количества входных векторов.
Для вычисления коэффициентов u[][] на каждой итерации алгоритма требуется определить расстояние от векторов до центра кластера. Сложность данной операции зависит от размерности входных данных и определении нормы. В виду того, что для разных задач могут быть введены разные нормы, и сложность вычисления расстояний может варьироваться, то в данной статье сложность вычисления расстояния будет считаться равной единице. В таком случае, для вычисления центров кластеров требуется <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-18T17:10:15Z

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

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

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

Последовательная сложность всего алгоритма складывается из сложности операций на каждой итерации умноженную на количество итераций.
Под операцией будем понимать выражение в языке с++ из пункта 1.5, находящееся в теле цикла (например, выражения "sum+= pow( dist(x[i], c[j]) / dist(x[i], c[k]), 2/(m-1));" или "uPrev[i][j]=u[i][j];" считаются за одну операцию). Так как при больших входных объёмах данных сложность алгоритма в большей степени зависит от количества входных данных, и незначительно зависит от сложности операций,то при оценке сложности алгоритма сложность выражений можно считать равной единице. Так как в данном алгоритме количество итераций не является фиксированным и зависит от:
* параметра <math>\varepsilon</math>
* набора входных векторов <math>x</math>
* выбора начальных коэффициентов <math>u</math>
то в данном пункте будет приведена сложность одной итерации относительно количества входных векторов.
Для вычисления коэффициентов u[][] на каждой итерации алгоритма требуется определить расстояние от векторов до центра кластера. Сложность данной операции зависит от размерности входных данных и определении нормы. В виду того, что для разных задач могут быть введены разные нормы, и сложность вычисления расстояний может варьироваться, то в данной статье сложность вычисления расстояния будет считаться равной единице. В таком случае, для вычисления центров кластеров требуется <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-18T17:02:32Z

Demon smd: /* Ресурс параллелизма алгоритма */

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

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

Последовательная сложность всего алгоритма складывается из сложности операций на каждой итерации умноженную на количество итераций.
Под операцией будем понимать выражение в языке с++ из пункта 1.5, находящееся в теле цикла (например, выражения "sum+= pow( dist(x[i], c[j]) / dist(x[i], c[k]), 2/(m-1));" или "uPrev[i][j]=u[i][j];" считаются за одну операцию). Так как при больших входных объёмах данных сложность алгоритма в большей степени зависит от количества входных данных, и незначительно зависит от сложности операций,то при оценке сложности алгоритма сложность выражений можно считать равной единице. Так как в данном алгоритме количество итераций не является фиксированным и зависит от:
* параметра <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-18T17:01:39Z

Demon smd:

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

* У вас в сложности фигурирует количество итераций. В литературе есть какие-то оценки требуемого количества итераций исходя из входных параметров? Если есть, то хорошо бы указать. [[Участник:Chalker|Chalker]] ([[Обсуждение участника:Chalker|обсуждение]]) 18:23, 18 декабря 2016 (MSK)
** Нет, в классической постановке задачи алгоритм работает пока есть улучшение результата (это описано в 1.1 пункт 4.) А количество итераций зависит от параметра эпсилон, входных данных и сгенерированного начального размещения.
* 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-18T16:45:56Z

Demon smd:

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

* У вас в сложности фигурирует количество итераций. В литературе есть какие-то оценки требуемого количества итераций исходя из входных параметров? Если есть, то хорошо бы указать. [[Участник:Chalker|Chalker]] ([[Обсуждение участника:Chalker|обсуждение]]) 18:23, 18 декабря 2016 (MSK)
** Нет, в классической постановке задачи алгоритм работает пока есть улучшение результата (это описано в 1.1 пункт 4.) А количество итераций зависит от параметра эпсилон, входных данных и сгенерированного начального размещения.
* 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-18T16:40:38Z

Demon smd:

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

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

Demon smd:

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

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

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

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

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

Последовательная сложность всего алгоритма складывается из сложности операций на каждой итерации умноженную на количество итераций.
Под операцией будем понимать выражение в языке с++ из пункта 1.5, находящееся в теле цикла (например, выражения "sum+= pow( dist(x[i], c[j]) / dist(x[i], c[k]), 2/(m-1));" или "uPrev[i][j]=u[i][j];" считаются за одну операцию). Так как при больших входных объёмах данных сложность алгоритма в большей степени зависит от количества входных данных, и незначительно зависит от сложности операций,то при оценке сложности алгоритма сложность выражений можно считать равной единице. Так как в данном алгоритме количество итераций не является фиксированным и зависит от:
* параметра <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-18T16:26:59Z

Demon smd:

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

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

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

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

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

Последовательная сложность всего алгоритма складывается из сложности операций на каждой итерации умноженную на количество итераций.
Под операцией будем понимать выражение в языке с++ из пункта 1.5, находящееся в теле цикла (например, выражения "sum+= pow( dist(x[i], c[j]) / dist(x[i], c[k]), 2/(m-1));" или "uPrev[i][j]=u[i][j];" считаются за одну операцию). Так как при больших входных объёмах данных сложность алгоритма в большей степени зависит от количества входных данных, и незначительно зависит от сложности операций,то при оценке сложности алгоритма сложность выражений можно считать равной единице. Так как в данном алгоритме количество итераций не является фиксированным и зависит от:
* параметра <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-02T20:28:39Z

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

= Статья [[Нечеткий алгоритм С средних]] =
* не указан вклад каждого автора [[Участник: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)

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

2016-11-26T14:21:04Z

Demon smd:

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

{{Assignment}}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

<source lang="C++">

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

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

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

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

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

}
return u;
}
</source>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

<references \>

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

2016-11-26T14:08:44Z

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

<source lang="C++">

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

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

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

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

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

}
return u;
}
</source>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

<references \>

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

2016-11-26T12:48:37Z

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

{{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:FCMCOMP1.jpg|thumb|center|1500px|Рисунок 2. Масштабируемость алгоритма. Зависимость сложности алгоритма от количества процессоров и входных данных при фиксированном количестве кластеров.]]
[[File:FCMCOMP2.jpg|thumb|center|1500px|Рисунок 3. Масштабируемость алгоритма. Зависимость сложности алгоритма от количества процессоров и кластеров при фиксированном количестве входных данных.]]

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

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

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

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

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

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

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

<references \>

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

2016-11-26T12:47:39Z

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

{{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 раз.

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

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

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

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

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

Как видно из предыдущих пунктов, масштабируется данный алгоритм хорошо. С увеличением количества процессоров время работы падает, а с увеличением количества входных данных и количества кластеров - растёт. На рисунках показаны результаты запусков алгоритма на разном количестве входных данных и процессоров. Исходных код программы можно найти здесь: https://github.com/demonsmd/superPrak
[[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:23:32Z

Demon smd:

{{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:19:45Z

Demon smd: /* Входные и выходные данные алгоритма */

{{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</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-13T09:45:48Z

Demon smd:

{{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-13T09:45:10Z

Demon smd:

{{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)</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-13T09:44:10Z

Demon smd:

{{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)</math>
| pf_width = <math>O(C^2*|X|)</math>
| input_data = <math>|X|*С</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-13T09:32:13Z

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

{{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*|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-13T09:29:24Z

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

{{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*|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|1200px|Рисунок 2. Масштабируемость алгоритма. Зависимость сложности алгоритма от количества процессоров и входных данных при фиксированном количестве кластеров.]]
[[File:FCMCOMP2.jpg|thumb|center|1200px|Рисунок 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-13T08:37:17Z

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

{{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*|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 раз.

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

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

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

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

- Например, тут: 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-13T08:27:24Z

Demon smd:

{{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*|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 раз.

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

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

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

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

<references \>

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

2016-10-04T15:56:07Z

Demon smd: /* Свойства алгоритма */

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

2016-10-04T15:55:34Z

Demon smd: /* Свойства алгоритма */

{{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*|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 раз.

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

<references \>

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

2016-10-04T15:55:06Z

Demon smd: /* Свойства алгоритма */

{{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*|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 раз.

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

<references \>

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

2016-10-04T15:53:21Z

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

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

2016-10-04T15:53:07Z

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

{{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*|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> - матрица принадлежности векторов кластерам

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

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

<references \>

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

2016-10-04T15:33:08Z

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

{{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)</math> операций, а для вычисления решающей функции - <math>O(2*C*N)</math> операций, где <math>N</math> - число входных векторов, а <math>C</math> - количество кластеров.

Таким образом итоговая сложность одной итерации составляет <math>O(C^2*N)</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> - матрица принадлежности векторов кластерам

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

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

<references \>

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

2016-10-04T15:30:16Z

Demon smd: /* Ресурс параллелизма алгоритма */

{{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: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> - матрица принадлежности векторов кластерам

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

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

<references \>

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

2016-10-04T15:23:22Z

Demon smd: /* Ресурс параллелизма алгоритма */

{{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: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>x_{i}</math> - набор входных векторов
* <math>C</math> - количество кластеров
* <math>m</math> - коэффициент неопределённости
* <math>\varepsilon > 0</math> - коэффициент, определяющий точность алгоритма.

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

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

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

<references \>

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

2016-10-02T11:56:05Z

Demon smd: /* Информационный граф */

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

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

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

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

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

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

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

<references \>

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

2016-10-02T11:55:42Z

Demon smd: /* Информационный граф */

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

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

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

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

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

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

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

<references \>

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

2016-10-02T11:51:27Z

Demon smd: /* Информационный граф */

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

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

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

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

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

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

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

<references \>

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

2016-10-02T11:51:09Z

Demon smd: /* Информационный граф */

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

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

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

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

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

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

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

<references \>

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

2016-10-02T11:50:50Z

Demon smd: /* Информационный граф */

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

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

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

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

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

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

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

<references \>

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

2016-10-02T11:50:29Z

Demon smd: /* Информационный граф */

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

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

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

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

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

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

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

<references \>

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

2016-10-02T11:47:18Z

Demon smd: /* Информационный граф */

{{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|1100px|Рисунок 1. Информационный граф алгоритма. (1)-(7) - это наборы последовательных действий (например, (2) - последовательные операции деления, взятия адреса и присваивания).]]

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

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

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

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

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

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

<references \>

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

2016-10-02T11:45:25Z

Demon smd: /* Информационный граф */

{{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|1000px|Рисунок 1. Информационный граф алгоритма. (1)-(7) - это наборы последовательных действий (например, (2) - последовательные операции деления, взятия адреса и присваивания).]]

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

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

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

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

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

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

<references \>

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

2016-10-02T11:44:26Z

Demon smd: /* Информационный граф */

{{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|1200px|Рисунок 1. Информационный граф алгоритма. (1)-(7) - это наборы последовательных действий (например, (2) - последовательные операции деления, взятия адреса и присваивания).]]

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

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

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

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

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

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

<references \>

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

2016-10-02T11:40:23Z

Demon smd: /* Информационный граф */

{{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)-(7) - это наборы последовательных действий (например, (2) - последовательные операции деления, взятия адреса и присваивания).]]

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

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

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

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

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

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

<references \>

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

2016-09-25T16:50:03Z

Demon smd: /* Вычисляемые данные */

{{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|Д.А.Гуськов]]

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

=== Общее описание алгоритма ===
Нечёткий алгоритм кластеризации С-средних был разработан (для случая 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>x_{i}</math> - набор входных векторов
* <math>C</math> - количество кластеров
* <math>m</math> - коэффициент неопределённости
* <math>\varepsilon > 0</math> - коэффициент, определяющий точность алгоритма.

==== Выходные данные алгоритма ====
* <math>u</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> - номер итерации алгоритма

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

<references \>

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

2016-09-25T16:49:31Z

Demon smd: /* Свойства и структура алгоритма */

{{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|Д.А.Гуськов]]

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

=== Общее описание алгоритма ===
Нечёткий алгоритм кластеризации С-средних был разработан (для случая 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>x_{i}</math> - набор входных векторов
* <math>C</math> - количество кластеров
* <math>m</math> - коэффициент неопределённости
* <math>\varepsilon > 0</math> - коэффициент, определяющий точность алгоритма.

==== Выходные данные алгоритма ====
* <math>u</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> - номер итерации алгоритма

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

<references \>

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

2016-09-25T16:17:42Z

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

{{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|Д.А.Гуськов]]

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

=== Общее описание алгоритма ===
Нечёткий алгоритм кластеризации С-средних был разработан (для случая 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>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>x_{i}</math> - набор входных векторов
* <math>x_{i}</math> - набор входных векторов

:<math>
\begin{align}
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}} & ; \\
c_{j} = {{\sum_{i = 1}^{n}{u_{i,j}^m} * x_{i}} \over {\sum_{i = 1}^{n}{u_{i,j}^m}}}
\end{align}
</math>

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

<references \>

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

2016-09-25T16:10:38Z

Demon smd: /* Свойства и структура алгоритма */

{{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|Д.А.Гуськов]]

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

=== Общее описание алгоритма ===
Нечёткий алгоритм кластеризации С-средних был разработан (для случая 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>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>
\begin{align}
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}} & ; \\
c_{j} = {{\sum_{i = 1}^{n}{u_{i,j}^m} * x_{i}} \over {\sum_{i = 1}^{n}{u_{i,j}^m}}}
\end{align}
</math>

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

<references \>

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

2016-09-25T16:08:10Z

Demon smd: /* Общее описание алгоритма */

{{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|Д.А.Гуськов]]

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

=== Общее описание алгоритма ===
Нечёткий алгоритм кластеризации С-средних был разработан (для случая 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>, являющийся критерием останова алгоритма. На выходе алгоритма получаем матрицу вероятностей принадлежности каждого входного вектора каждому кластеру.

Нечеткий алгоритм С средних для каждого вектора определяет случайным образом значения принадлежности вектора к каждому кластеру и запускает итерационный процесс, на каждой итерации которого происходит:
\begin{align}
1) Расчёт центров кластеров.

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

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

4) Расчёт значения решающей функции и сравнение этого значения со значением решающей функции на предшествующей итерации.Если их разница меньше установленного значения, то алгоритм прекращает работу.
\end{align}

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

:<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>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>
\begin{align}
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}} & ; \\
c_{j} = {{\sum_{i = 1}^{n}{u_{i,j}^m} * x_{i}} \over {\sum_{i = 1}^{n}{u_{i,j}^m}}}
\end{align}
</math>

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

<references \>