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

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

2016-12-18T20:11:12Z

Yushin:

{{Assignment|{{REVISIONUSER}}}}

{{algorithm
| name = Нечеткий алгоритм C средних
| serial_complexity = <math>O(Mdc^2i)</math>, <math>i</math> - количество итераций
| input_data = <math>M*d</math>, [количество наблюдений * размерность]
| output_data = <math>M*c</math>, [количество наблюдений * количество кластеров]
| pf_height = <math>2i</math>
| pf_width = <math>n</math>
}}

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

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

== Общее описание алгоритма ==
Кластеризация - это объединение объектов в группы (кластеры) на основе схожести признаков для объектов одной группы и отличий между группами. Нечеткий алгоритм C Средних (Fuzzy C-means, FCM) - алгоритм кластеризации, позволяющий объектам принадлежать с различной степенью нескольким кластерам одновременно. Впервые алгоритм был предложен J.C. Dunn в 1973 <ref>[http://www.tandfonline.com/doi/abs/10.1080/01969727308546046 | J. C. Dunn. A Fuzzy Relative of the ISODATA Process and Its Use in Detecting Compact Well-Separated Clusters. Journal of Cybernetics, volume 3,1973 - Issue 3, pp 32-57]</ref>. Нечеткое разбиение позволяет просто решить проблему объектов кластеризации, расположенных на границе двух кластеров - им назначают степени принадлежностей равные 0.5.

Входные данные алгоритма: набор векторов, которые следует кластеризовать.

Параметры алгоритма: <math>c</math> - количество кластеров;<math>m >= 1</math> - экспоненциальный вес, определяющий нечеткость кластеров; <math>\varepsilon</math> - параметр останова алгоритма.

Выходные данные: матрица вероятностей принадлежности векторов кластерам.

Краткое описание алгоритма:

* Задать параметры алгоритма.

* Сгенерировать случайную матрицу принадлежностей векторов кластерам (матрицу нечеткого разбиения).

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

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

Пусть <math> W = w_{ij} \in[0,1],\; i = 1, ..., M, \; j = 1, ..., c</math> - матрица разбиения, где <math>w_{i,j}</math> - степень принадлежности объекта <math>i</math> к кластеру <math>j</math>; <math>c</math> - количество кластеров, <math>M</math> - количество векторов, <math>X_i</math> - набор входных векторов размерности <math>d</math>.

В качестве нормы предлагается максимум-норма: <math>||W|| = \max_{i,j} |w_{i,j}|</math>

При этом элементы матрицы должны удовлетворять условиям:

* <math>\sum_{j = 1}^c w_{ij} = 1, i = 1, ..., M</math>                <math>(1)</math>
* <math>0 < \sum_{i = 1}^M w_{ij} < M, j = 1, ..., c</math>       <math>(2)</math>

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

1) Задаем параметры алгоритма: <math>c</math> - количество кластеров; <math>m >= 1</math> - экспоненциальный вес, определяющий нечеткость кластеров; <math>\varepsilon > 0</math> - параметр останова алгоритма.

2) Генерируем случайным образом матрицу нечеткого разбиения с учетом условий <math>(1)</math> и <math>(2)</math>

3) Рассчитываем центроиды (центры кластеров): <math>V_j = {{\sum_{i=1}^M w_{ij}^m * X_i} \over {\sum_{i=1}^M w_{ij}^m}}, j = 1, ..., c</math>

4) Рассчитываем расстояния между объектами <math>X</math> и центроидами:

<math>D_{ij} = {||X_i - V_j||}, i = 1,...,M; j = 1,...,c </math>

5) Пересчет элементов матрицы разбиения:

при <math>D_{ij} >0</math> : <math>w_{ij} = {{1}\over {{ (\sum_{k=1}^c {{D_{ij}}\over{D_{ik}}} ) }^{2/(m-1)}}}, j = 1,...,c</math>

при <math>D_{ij} =0</math> : <math>w_{ij} = \delta_{ij}, j = 1,...,c</math>, где <math>\delta_{ij}</math> - символ Кронекера

6) Если <math>|| F - F^{*} || < \varepsilon </math>, где <math>F^{*}</math> - матрица нечеткого разбиения предыдущей итерации, то идем далее, иначе возвращаемся на пункт 3.

7) Конец.

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

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

* Поиск <math>V_j</math> - расчет центроидов (пункт 3 алгоритма)
* Нахождение <math>D_{ij}</math> - расстояний между объектами (пункт 4 алгоритма)
* Пересчет <math>w_{ij}</math> - элементов матрицы разбиения (пункт 5 алгоритма)

== Макроструктура алгоритма ==
Основные шаги при реализации алгоритма
* Генерация случайной матрицы размера <math>M*c</math>, проверка условий
* Расчет центроидов – по сути, скалярное произведение с нормировкой
* Расчет расстояний – в общепринятом случае является скалярным произведением
* Пересчет матрицы – по сути, скалярное произведение
* Проверка условий останова – вычисление нормы

== Схема реализации последовательного алгоритма ==
float ** FuzzyCMeans (float** X, c, m, eps){
n = X.size();
r = X[0].size();
centers = generateZeroFill(c, r)
Wprev = genetateRandFill(n, c);
W = Wprev;
while (true){
// обновляем центры кластеров
for (int i=0; i<c; i++){
float * num = new float []();
float den = 0;
for (int j=0; j<n; j++){
num += pow(W[j][i], m) * X[j];
den+=pow(W[j][i], m);
}
centers[i] = num / den;
}
//обновляем вероятности W и считаем расстояние между матрицами W и Wprev
float max_diff = 0;
for (int i=0; i<n; i++)
for (int j=0; j<c; j++){
total = 0;
for (int m=0; m<с; m++)
total += pow(distance(X[i], centers[j]) / distance(X[i], centers[m]), 2/(m-1));
W[i][j] = 1/total;
max_diff = max(abs(Wprev[i][j]-W[i][j]), max_diff);
Wprev[i][j] = W[i][j];
}
if (max_diff < eps):
break;
}
return W;
}

== Последовательная сложность алгоритма ==
Последовательная сложность алгоритма состоит из сложности каждой итерации умноженной на их количество. Так как число итераций заранее неизвестно и зависит от входных параметров, рассмотрим сложность на каждой итерации. Наибольшую сложность представляет собой пересчет матрицы, сложность которого <math>O(c^2 nd)</math> (по сравнению со сложностью <math>O(cnd)</math> расчета расстояний, вычисления центроидов и проверки условия останова). Итого общая сложность алгоритма <math>O(c^2 ndi)</math>

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

'''Первый ярус''' состоит из <math>M</math> параллельных операций 1, 2, совершаемых в цикле <math>c</math> раз для каждого кластера.

'''Операция 1''': <math>w_{ij}^m</math>, где <math>j</math> - номер итерации в цикле, <math>i</math> - номер параллельной ветви.

'''Операция 2''': <math>w_{ij}^m*X_i</math>

Здесь <math>j</math> - номер итерации в цикле, <math>i</math> - номер параллельной ветви.

На выходе из каждой ветки получаем вектор размера <math>1</math> x <math>c</math> и матрицу размера <math>d</math> x <math>c</math>.
Далее совершаем поэлементное сложение векторов и матриц соответственно, а затем делим каждый столбец в матрице на соответствующий элемент в векторе.

'''Второй ярус''' состоит их <math>M</math> параллельных операций 3, 4, 5 также совершаемых в цикле <math>c</math> раз.

'''Операция 3''': обновление значения <math>w_{ij}</math> по указанной в разделе 1.2 в пункте 5 формуле.

'''Операция 4''': <math>maximum = max(|w_{ij} - w_{ij}^{prev}|, maximum)</math>.

'''Операция 5''': <math>w_{ij}^{prev} = w_{ij}</math>.

Здесь <math>j</math> - номер итерации в цикле, <math>i</math> - номер параллельной ветви.

На выходе из каждой ветки получаем число <math>maximum</math>. Далее находим максимальное значение из полученных величин для каждой ветки. Затем проверяем условие останова алгоритма.

[[File:Scheme3.JPG]]

== Ресурс параллелизма алгоритма ==
Параллельная сложность алгоритма: <math>M*c^2*i</math>. Такая сложность получается за счет распараллеливания на каждом ярусе <math>M</math> операций. Иерархическая структура параллелизма подробно описана в [[#Информационный граф|п.1.7]].

В алгоритме не возникает скошенного параллелизма.

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

* Входные данные алгоритма: набор векторов <math>x_i</math> размерности <math>d</math>, где <math>i = 1,...,M</math>; <math>M</math> - количество векторов.
* Объем входных данных: <math>M*d</math> , [количество наблюдений * размерность].
* Выходные данные алгоритма: матрица вероятностей принадлежности векторов кластерам <math>M</math> на <math>c</math>.
* Объем выходных данных: <math>M*c</math> , [количество наблюдений * количество кластеров].

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

* Соотношение последовательной и параллельной сложности: <math>M</math>
* Вычислительная мощность: <math>{dc^2i} \over {c+d}</math>.
* Устойчивость: алгоритм не является устойчивым, поэтому существует много исследований о том, как первоначально выбрать параметры кластеризации.
* Сбалансированность: в данном алгоритме операция умножения доминирует над операцией сложения. Операции между параллельными ветвями сбалансированы.
* Детерминированность: алгоритм не является детерминированным, так как матрица нечеткого разбиение генерируется произвольно.
* Степень исхода вершины информационного графа (для одной итерации): 2. Если выходные данные пошли на следующую итерацию: 3.

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

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

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

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

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

Проведём исследование масштабируемости параллельной реализации нечеткого алгоритма С-средних.
Исследование проводилось на суперкомпьютере "Ломоносов"<ref name="Lom">Воеводин Вл., Жуматий С., Соболев С., Антонов А., Брызгалов П., Никитенко Д., Стефанов К., Воеводин Вад. Практика суперкомпьютера «Ломоносов» // Открытые системы, 2012, N 7, С. 36-39.</ref> [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета].
Была исследована собственная параллельная реализация алгоритма, написанная на языке C++ с использованием стандарта MPI. Сборка программы производилась при помощи компилятора компании Intel версии 13.1.0 с использованием библиотеки intelMPI версии 4.1.0 . Расчеты проводились в разделе test на узлах со следующими характеристиками: количество GPU - 0, количество ядер - 8 ядер архитектуры x86, количество памяти - 12 Гб.

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

* число процессоров [1 : 128];
* размер матрицы [10000 : 80000].

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

* минимальная эффективность реализации 0,33%;
* максимальная эффективность реализации 9,4%.

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

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

Построим оценки масштабируемости выбранной реализации нечеткого алгоритма С-средних:
* По числу процессов: 0.007. При увеличении числа процессов эффективность на рассмотренной области изменений параметров запуска увеличивается.
* По размеру задачи: -0.0016. При увеличении размера задачи эффективность уменьшается.
* По двум направлениям: 0,000077. При рассмотрении увеличения как вычислительной сложности, так и числа процессов на всей рассмотренной области значений эффективность увеличивается, однако скорость увеличения эффективности небольшая.

Была использована следующая реализация алгоритма.

#include <mpi.h>
#include <stdio.h>
#include <iostream>
#include <stdlib.h>
#include <math.h>
#include <string.h>
#include <time.h>
using namespace std;
double **x; //input matrix of size (n x x_dim)
int n;
int x_dim;
double **centroids; //cluster centroids matrix of size (n_cluster x x_dim)
int n_cluster; // number of clusters
double **w; //probability matrix of size (n x n_cluster)
double **dist; //distances matrix of size (n x n_cluster)
double eps; //max error
double m; //parameter of algo
int max_iter; // max num of iterations
double **num;
double *den;
double *allden;
double *err;
double *total_err;
int rank, size;
double ** generateZerosMatrix(int r, int c){
double ** arr = new double* [r];
for (int i = 0; i < r; ++i){
arr[i] = new double[c]();
}
return arr;
}
int generate_data()
{
//generate matrix
x = generateZerosMatrix(n, x_dim);
centroids = generateZerosMatrix(n_cluster, x_dim);
w = generateZerosMatrix(n, n_cluster);
dist = generateZerosMatrix(n, n_cluster);
num = generateZerosMatrix(n_cluster, x_dim);
//generate vectors
den = new double [n_cluster]();
allden = new double [n_cluster]();
//for stopping algorithm
err = new double;
total_err = new double;
srand(time(0));
//initialize w randomly with restrictions
for (int i = 0; i < n; ++i){
double sum = 0;
for (int j = 0; j < n_cluster; ++j){
w[i][j] = rand();
sum += w[i][j];
}
for (int j = 0; j < n_cluster; ++j){
w[i][j] /= sum;
}
}
//initialize x randomly
for (int i = 0; i < n; ++i)
for (int j = 0; j < x_dim; ++j)
x[i][j] = rand();
return 0;
}
double make_iteration() {
// calculate centroids centers
for (int i = rank; i < n; i+=size)
for (int j = 0; j < n_cluster; ++j){
double mu = pow(w[i][j], m);
den[j] += mu;
for (int k = 0; k < x_dim; ++k)
num[j][k] = mu * x[i][k];
}
MPI_Allreduce(den, allden, n_cluster, MPI_DOUBLE, MPI_SUM, MPI_COMM_WORLD);
for (int j=0; j < n_cluster; ++j)
MPI_Allreduce(num[j], centroids[j], x_dim, MPI_DOUBLE, MPI_SUM, MPI_COMM_WORLD);
for (int i = 0; i < n_cluster; ++i)
for (int j = 0; j < x_dim; ++j)
centroids[i][j] /= allden[i];
// calculate distances and probabilities, check stop conditions
double err = 0.0;
for (int i = rank; i < n; i+=size)
for (int j = 0; j < n_cluster; ++j){
for (int k = 0; k < x_dim; ++k)
dist[i][j] += (x[i][k] - centroids[j][k]) * (x[i][k] - centroids[j][k]);
double w_prev = w[i][j];
for (int k = 0; k < n_cluster; ++k)
w[i][j] += dist[i][j] / dist[i][k];
w[i][j] = 1.0 / pow(w[i][j], 1.0 / (m - 1));
err = fmax(err, abs(w_prev - w[i][j]));
}
return err;
}
int FCM(){
*total_err = eps+1;
int cur_iter = 0;
while (cur_iter < max_iter && *total_err > eps){
*err = make_iteration();
MPI_Allreduce(err, total_err, 1, MPI_DOUBLE, MPI_MAX, MPI_COMM_WORLD);
cur_iter++;
}
return cur_iter;
}
void clearMatrix(double ** matr, int r, int c){
for (int i = 0; i < r; ++i){
delete [] matr[i];
}
delete [] matr;
}
int memory_free(){
clearMatrix(x, n, x_dim);
clearMatrix(centroids, n_cluster, x_dim);
clearMatrix(w, n_cluster, n);
clearMatrix(num, n_cluster, x_dim);
clearMatrix(dist, n, n_cluster);
delete [] den;
delete [] allden;
delete err;
delete total_err;
return 0;
}
int main(int argc, char **argv){
MPI_Init(&argc, &argv);
MPI_Comm_size(MPI_COMM_WORLD, &size);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
int n_repeat = strtol(argv[1], NULL, 10);
int nx_min = strtol(argv[2], NULL, 10);
int nx_max = strtol(argv[3], NULL, 10);
int step = strtol(argv[4], NULL, 10);
x_dim = strtol(argv[5], NULL, 10);
m = strtod(argv[6], NULL);
n_cluster = strtol(argv[7], NULL, 10);
max_iter = strtol(argv[8], NULL, 10);
eps = strtod(argv[9], NULL);
//for all input matrix sizes
for (n = nx_min; n <= nx_max; n += step){
double start, finish, time_elapsed_iter=0;
int total_iterations = 0;
//repeat for getting mean value
for (int i = 0; i < n_repeat; ++i) {
generate_data();
MPI_Barrier(MPI_COMM_WORLD);
start = MPI_Wtime();
total_iterations += FCM();
finish = MPI_Wtime();
memory_free();
time_elapsed_iter += (finish-start);
}
time_elapsed_iter /= total_iterations;
if (rank == 0) {
cout << n << " " << size << " " << time_elapsed_iter << endl;
}
}
MPI_Finalize();
}

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

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

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

* Реализация алгоритма на POSTGRESQL: http://num-meth.srcc.msu.ru/zhurnal/tom_2012/pdf/v13r207.pdf
* Библиотека для MATLAB: http://www.mathworks.com/help/fuzzy/fcm.html (распространяется на коммерческой основе)

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

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

2016-12-18T20:10:26Z

Yushin:

{{Assignment|{{REVISIONUSER}}}}

{{algorithm
| name = Нечеткий алгоритм C средних
| serial_complexity = <math>O(Mdc^2i)</math>, <math>i</math> - количество итераций
| input_data = <math>M*d</math>, [количество наблюдений * размерность]
| output_data = <math>M*c</math>, [количество наблюдений * количество кластеров]
| pf_height = <math>2i</math>
| pf_width = <math>n</math>
}}

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

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

== Общее описание алгоритма ==
Кластеризация - это объединение объектов в группы (кластеры) на основе схожести признаков для объектов одной группы и отличий между группами. Нечеткий алгоритм C Средних (Fuzzy C-means, FCM) - алгоритм кластеризации, позволяющий объектам принадлежать с различной степенью нескольким кластерам одновременно. Впервые алгоритм был предложен J.C. Dunn в 1973 <ref>[http://www.tandfonline.com/doi/abs/10.1080/01969727308546046 | J. C. Dunn. A Fuzzy Relative of the ISODATA Process and Its Use in Detecting Compact Well-Separated Clusters. Journal of Cybernetics, volume 3,1973 - Issue 3, pp 32-57]</ref>. Нечеткое разбиение позволяет просто решить проблему объектов кластеризации, расположенных на границе двух кластеров - им назначают степени принадлежностей равные 0.5.

Входные данные алгоритма: набор векторов, которые следует кластеризовать.

Параметры алгоритма: <math>c</math> - количество кластеров;<math>m >= 1</math> - экспоненциальный вес, определяющий нечеткость кластеров; <math>\varepsilon</math> - параметр останова алгоритма.

Выходные данные: матрица вероятностей принадлежности векторов кластерам.

Краткое описание алгоритма:

* Задать параметры алгоритма.

* Сгенерировать случайную матрицу принадлежностей векторов кластерам (матрицу нечеткого разбиения).

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

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

Пусть <math> W = w_{ij} \in[0,1],\; i = 1, ..., M, \; j = 1, ..., c</math> - матрица разбиения, где <math>w_{i,j}</math> - степень принадлежности объекта <math>i</math> к кластеру <math>j</math>; <math>c</math> - количество кластеров, <math>M</math> - количество векторов, <math>X_i</math> - набор входных векторов размерности <math>d</math>.

В качестве нормы предлагается максимум-норма: <math>||W|| = \max_{i,j} |w_{i,j}|</math>

При этом элементы матрицы должны удовлетворять условиям:

* <math>\sum_{j = 1}^c w_{ij} = 1, i = 1, ..., M</math>                <math>(1)</math>
* <math>0 < \sum_{i = 1}^M w_{ij} < M, j = 1, ..., c</math>       <math>(2)</math>

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

1) Задаем параметры алгоритма: <math>c</math> - количество кластеров; <math>m >= 1</math> - экспоненциальный вес, определяющий нечеткость кластеров; <math>\varepsilon > 0</math> - параметр останова алгоритма.

2) Генерируем случайным образом матрицу нечеткого разбиения с учетом условий <math>(1)</math> и <math>(2)</math>

3) Рассчитываем центроиды (центры кластеров): <math>V_j = {{\sum_{i=1}^M w_{ij}^m * X_i} \over {\sum_{i=1}^M w_{ij}^m}}, j = 1, ..., c</math>

4) Рассчитываем расстояния между объектами <math>X</math> и центроидами:

<math>D_{ij} = {||X_i - V_j||}, i = 1,...,M; j = 1,...,c </math>

5) Пересчет элементов матрицы разбиения:

при <math>D_{ij} >0</math> : <math>w_{ij} = {{1}\over {{ (\sum_{k=1}^c {{D_{ij}}\over{D_{ik}}} ) }^{2/(m-1)}}}, j = 1,...,c</math>

при <math>D_{ij} =0</math> : <math>w_{ij} = \delta_{ij}, j = 1,...,c</math>, где <math>\delta_{ij}</math> - символ Кронекера

6) Если <math>|| F - F^{*} || < \varepsilon </math>, где <math>F^{*}</math> - матрица нечеткого разбиения предыдущей итерации, то идем далее, иначе возвращаемся на пункт 3.

7) Конец.

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

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

* Поиск <math>V_j</math> - расчет центроидов (пункт 3 алгоритма)
* Нахождение <math>D_{ij}</math> - расстояний между объектами (пункт 4 алгоритма)
* Пересчет <math>w_{ij}</math> - элементов матрицы разбиения (пункт 5 алгоритма)

== Макроструктура алгоритма ==
Основные шаги при реализации алгоритма
* Генерация случайной матрицы размера <math>M*c</math>, проверка условий
* Расчет центроидов – по сути, скалярное произведение с нормировкой
* Расчет расстояний – в общепринятом случае является скалярным произведением
* Пересчет матрицы – по сути, скалярное произведение
* Проверка условий останова – вычисление нормы

== Схема реализации последовательного алгоритма ==
float ** FuzzyCMeans (float** X, c, m, eps){
n = X.size();
r = X[0].size();
centers = generateZeroFill(c, r)
Wprev = genetateRandFill(n, c);
W = Wprev;
while (true){
// обновляем центры кластеров
for (int i=0; i<c; i++){
float * num = new float []();
float den = 0;
for (int j=0; j<n; j++){
num += pow(W[j][i], m) * X[j];
den+=pow(W[j][i], m);
}
centers[i] = num / den;
}
//обновляем вероятности W и считаем расстояние между матрицами W и Wprev
float max_diff = 0;
for (int i=0; i<n; i++)
for (int j=0; j<c; j++){
total = 0;
for (int m=0; m<с; m++)
total += pow(distance(X[i], centers[j]) / distance(X[i], centers[m]), 2/(m-1));
W[i][j] = 1/total;
max_diff = max(abs(Wprev[i][j]-W[i][j]), max_diff);
Wprev[i][j] = W[i][j];
}
if (max_diff < eps):
break;
}
return W;
}

== Последовательная сложность алгоритма ==
Последовательная сложность алгоритма состоит из сложности каждой итерации умноженной на их количество. Так как число итераций заранее неизвестно и зависит от входных параметров, рассмотрим сложность на каждой итерации. Наибольшую сложность представляет собой пересчет матрицы, сложность которого <math>O(c^2 nd)</math> (по сравнению со сложностью <math>O(cnd)</math> расчета расстояний, вычисления центроидов и проверки условия останова). Итого общая сложность алгоритма <math>O(c^2 ndi)</math>

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

'''Первый ярус''' состоит из <math>M</math> параллельных операций 1, 2, совершаемых в цикле <math>c</math> раз для каждого кластера.

'''Операция 1''': <math>w_{ij}^m</math>, где <math>j</math> - номер итерации в цикле, <math>i</math> - номер параллельной ветви.

'''Операция 2''': <math>w_{ij}^m*X_i</math>

Здесь <math>j</math> - номер итерации в цикле, <math>i</math> - номер параллельной ветви.

На выходе из каждой ветки получаем вектор размера <math>1</math> x <math>c</math> и матрицу размера <math>d</math> x <math>c</math>.
Далее совершаем поэлементное сложение векторов и матриц соответственно, а затем делим каждый столбец в матрице на соответствующий элемент в векторе.

'''Второй ярус''' состоит их <math>M</math> параллельных операций 3, 4, 5 также совершаемых в цикле <math>c</math> раз.

'''Операция 3''': обновление значения <math>w_{ij}</math> по указанной в разделе 1.2 в пункте 5 формуле.

'''Операция 4''': <math>maximum = max(|w_{ij} - w_{ij}^{prev}|, maximum)</math>.

'''Операция 5''': <math>w_{ij}^{prev} = w_{ij}</math>.

Здесь <math>j</math> - номер итерации в цикле, <math>i</math> - номер параллельной ветви.

На выходе из каждой ветки получаем число <math>maximum</math>. Далее находим максимальное значение из полученных величин для каждой ветки. Затем проверяем условие останова алгоритма.

[[File:Scheme3.JPG]]

== Ресурс параллелизма алгоритма ==
Параллельная сложность алгоритма: <math>M*c^2*i</math>. Такая сложность получается за счет распараллеливания на каждом ярусе <math>M</math> операций. Иерархическая структура параллелизма подробно описана в [[#Информационный граф|п.1.7]].

В алгоритме не возникает скошенного параллелизма.

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

* Входные данные алгоритма: набор векторов <math>x_i</math> размерности <math>d</math>, где <math>i = 1,...,M</math>; <math>M</math> - количество векторов.
* Объем входных данных: <math>M*d</math> , [количество наблюдений * размерность].
* Выходные данные алгоритма: матрица вероятностей принадлежности векторов кластерам <math>M</math> на <math>c</math>.
* Объем выходных данных: <math>M*c</math> , [количество наблюдений * количество кластеров].

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

* Соотношение последовательной и параллельной сложности: <math>M</math>
* Вычислительная мощность: <math>{dc^2i} \over {c+d}</math>.
* Устойчивость: алгоритм не является устойчивым, поэтому существует много исследований о том, как первоначально выбрать параметры кластеризации.
* Сбалансированность: в данном алгоритме операция умножения доминирует над операцией сложения. Операции между параллельными ветвями сбалансированы.
* Детерминированность: алгоритм не является детерминированным, так как матрица нечеткого разбиение генерируется произвольно.
* Степень исхода вершины информационного графа ( для одной итерации): 2. Если выходные данные пошли на следующую итерацию: 3.

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

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

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

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

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

Проведём исследование масштабируемости параллельной реализации нечеткого алгоритма С-средних.
Исследование проводилось на суперкомпьютере "Ломоносов"<ref name="Lom">Воеводин Вл., Жуматий С., Соболев С., Антонов А., Брызгалов П., Никитенко Д., Стефанов К., Воеводин Вад. Практика суперкомпьютера «Ломоносов» // Открытые системы, 2012, N 7, С. 36-39.</ref> [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета].
Была исследована собственная параллельная реализация алгоритма, написанная на языке C++ с использованием стандарта MPI. Сборка программы производилась при помощи компилятора компании Intel версии 13.1.0 с использованием библиотеки intelMPI версии 4.1.0 . Расчеты проводились в разделе test на узлах со следующими характеристиками: количество GPU - 0, количество ядер - 8 ядер архитектуры x86, количество памяти - 12 Гб.

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

* число процессоров [1 : 128];
* размер матрицы [10000 : 80000].

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

* минимальная эффективность реализации 0,33%;
* максимальная эффективность реализации 9,4%.

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

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

Построим оценки масштабируемости выбранной реализации нечеткого алгоритма С-средних:
* По числу процессов: 0.007. При увеличении числа процессов эффективность на рассмотренной области изменений параметров запуска увеличивается.
* По размеру задачи: -0.0016. При увеличении размера задачи эффективность уменьшается.
* По двум направлениям: 0,000077. При рассмотрении увеличения как вычислительной сложности, так и числа процессов на всей рассмотренной области значений эффективность увеличивается, однако скорость увеличения эффективности небольшая.

Была использована следующая реализация алгоритма.

#include <mpi.h>
#include <stdio.h>
#include <iostream>
#include <stdlib.h>
#include <math.h>
#include <string.h>
#include <time.h>
using namespace std;
double **x; //input matrix of size (n x x_dim)
int n;
int x_dim;
double **centroids; //cluster centroids matrix of size (n_cluster x x_dim)
int n_cluster; // number of clusters
double **w; //probability matrix of size (n x n_cluster)
double **dist; //distances matrix of size (n x n_cluster)
double eps; //max error
double m; //parameter of algo
int max_iter; // max num of iterations
double **num;
double *den;
double *allden;
double *err;
double *total_err;
int rank, size;
double ** generateZerosMatrix(int r, int c){
double ** arr = new double* [r];
for (int i = 0; i < r; ++i){
arr[i] = new double[c]();
}
return arr;
}
int generate_data()
{
//generate matrix
x = generateZerosMatrix(n, x_dim);
centroids = generateZerosMatrix(n_cluster, x_dim);
w = generateZerosMatrix(n, n_cluster);
dist = generateZerosMatrix(n, n_cluster);
num = generateZerosMatrix(n_cluster, x_dim);
//generate vectors
den = new double [n_cluster]();
allden = new double [n_cluster]();
//for stopping algorithm
err = new double;
total_err = new double;
srand(time(0));
//initialize w randomly with restrictions
for (int i = 0; i < n; ++i){
double sum = 0;
for (int j = 0; j < n_cluster; ++j){
w[i][j] = rand();
sum += w[i][j];
}
for (int j = 0; j < n_cluster; ++j){
w[i][j] /= sum;
}
}
//initialize x randomly
for (int i = 0; i < n; ++i)
for (int j = 0; j < x_dim; ++j)
x[i][j] = rand();
return 0;
}
double make_iteration() {
// calculate centroids centers
for (int i = rank; i < n; i+=size)
for (int j = 0; j < n_cluster; ++j){
double mu = pow(w[i][j], m);
den[j] += mu;
for (int k = 0; k < x_dim; ++k)
num[j][k] = mu * x[i][k];
}
MPI_Allreduce(den, allden, n_cluster, MPI_DOUBLE, MPI_SUM, MPI_COMM_WORLD);
for (int j=0; j < n_cluster; ++j)
MPI_Allreduce(num[j], centroids[j], x_dim, MPI_DOUBLE, MPI_SUM, MPI_COMM_WORLD);
for (int i = 0; i < n_cluster; ++i)
for (int j = 0; j < x_dim; ++j)
centroids[i][j] /= allden[i];
// calculate distances and probabilities, check stop conditions
double err = 0.0;
for (int i = rank; i < n; i+=size)
for (int j = 0; j < n_cluster; ++j){
for (int k = 0; k < x_dim; ++k)
dist[i][j] += (x[i][k] - centroids[j][k]) * (x[i][k] - centroids[j][k]);
double w_prev = w[i][j];
for (int k = 0; k < n_cluster; ++k)
w[i][j] += dist[i][j] / dist[i][k];
w[i][j] = 1.0 / pow(w[i][j], 1.0 / (m - 1));
err = fmax(err, abs(w_prev - w[i][j]));
}
return err;
}
int FCM(){
*total_err = eps+1;
int cur_iter = 0;
while (cur_iter < max_iter && *total_err > eps){
*err = make_iteration();
MPI_Allreduce(err, total_err, 1, MPI_DOUBLE, MPI_MAX, MPI_COMM_WORLD);
cur_iter++;
}
return cur_iter;
}
void clearMatrix(double ** matr, int r, int c){
for (int i = 0; i < r; ++i){
delete [] matr[i];
}
delete [] matr;
}
int memory_free(){
clearMatrix(x, n, x_dim);
clearMatrix(centroids, n_cluster, x_dim);
clearMatrix(w, n_cluster, n);
clearMatrix(num, n_cluster, x_dim);
clearMatrix(dist, n, n_cluster);
delete [] den;
delete [] allden;
delete err;
delete total_err;
return 0;
}
int main(int argc, char **argv){
MPI_Init(&argc, &argv);
MPI_Comm_size(MPI_COMM_WORLD, &size);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
int n_repeat = strtol(argv[1], NULL, 10);
int nx_min = strtol(argv[2], NULL, 10);
int nx_max = strtol(argv[3], NULL, 10);
int step = strtol(argv[4], NULL, 10);
x_dim = strtol(argv[5], NULL, 10);
m = strtod(argv[6], NULL);
n_cluster = strtol(argv[7], NULL, 10);
max_iter = strtol(argv[8], NULL, 10);
eps = strtod(argv[9], NULL);
//for all input matrix sizes
for (n = nx_min; n <= nx_max; n += step){
double start, finish, time_elapsed_iter=0;
int total_iterations = 0;
//repeat for getting mean value
for (int i = 0; i < n_repeat; ++i) {
generate_data();
MPI_Barrier(MPI_COMM_WORLD);
start = MPI_Wtime();
total_iterations += FCM();
finish = MPI_Wtime();
memory_free();
time_elapsed_iter += (finish-start);
}
time_elapsed_iter /= total_iterations;
if (rank == 0) {
cout << n << " " << size << " " << time_elapsed_iter << endl;
}
}
MPI_Finalize();
}

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

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

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

* Реализация алгоритма на POSTGRESQL: http://num-meth.srcc.msu.ru/zhurnal/tom_2012/pdf/v13r207.pdf
* Библиотека для MATLAB: http://www.mathworks.com/help/fuzzy/fcm.html (распространяется на коммерческой основе)

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

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

2016-12-18T20:03:19Z

Yushin:

{{Assignment|{{REVISIONUSER}}}}

{{algorithm
| name = Нечеткий алгоритм C средних
| serial_complexity = <math>O(Mdc^2i)</math>, <math>i</math> - количество итераций
| input_data = <math>M*d</math>, [количество наблюдений * размерность]
| output_data = <math>M*c</math>, [количество наблюдений * количество кластеров]
| pf_height = <math>2i</math>
| pf_width = <math>n</math>
}}

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

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

== Общее описание алгоритма ==
Кластеризация - это объединение объектов в группы (кластеры) на основе схожести признаков для объектов одной группы и отличий между группами. Нечеткий алгоритм C Средних (Fuzzy C-means, FCM) - алгоритм кластеризации, позволяющий объектам принадлежать с различной степенью нескольким кластерам одновременно. Впервые алгоритм был предложен J.C. Dunn в 1973 <ref>[http://www.tandfonline.com/doi/abs/10.1080/01969727308546046 | J. C. Dunn. A Fuzzy Relative of the ISODATA Process and Its Use in Detecting Compact Well-Separated Clusters. Journal of Cybernetics, volume 3,1973 - Issue 3, pp 32-57]</ref>. Нечеткое разбиение позволяет просто решить проблему объектов кластеризации, расположенных на границе двух кластеров - им назначают степени принадлежностей равные 0.5.

Входные данные алгоритма: набор векторов, которые следует кластеризовать.

Параметры алгоритма: <math>c</math> - количество кластеров;<math>m >= 1</math> - экспоненциальный вес, определяющий нечеткость кластеров; <math>\varepsilon</math> - параметр останова алгоритма.

Выходные данные: матрица вероятностей принадлежности векторов кластерам.

Краткое описание алгоритма:

* Задать параметры алгоритма.

* Сгенерировать случайную матрицу принадлежностей векторов кластерам (матрицу нечеткого разбиения).

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

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

Пусть <math> W = w_{ij} \in[0,1],\; i = 1, ..., M, \; j = 1, ..., c</math> - матрица разбиения, где <math>w_{i,j}</math> - степень принадлежности объекта <math>i</math> к кластеру <math>j</math>; <math>c</math> - количество кластеров, <math>M</math> - количество векторов, <math>X_i</math> - набор входных векторов размерности <math>d</math>.

В качестве нормы предлагается максимум-норма: <math>||W|| = \max_{i,j} |w_{i,j}|</math>

При этом элементы матрицы должны удовлетворять условиям:

* <math>\sum_{j = 1}^c w_{ij} = 1, i = 1, ..., M</math>                <math>(1)</math>
* <math>0 < \sum_{i = 1}^M w_{ij} < M, j = 1, ..., c</math>       <math>(2)</math>

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

1) Задаем параметры алгоритма: <math>c</math> - количество кластеров; <math>m >= 1</math> - экспоненциальный вес, определяющий нечеткость кластеров; <math>\varepsilon > 0</math> - параметр останова алгоритма.

2) Генерируем случайным образом матрицу нечеткого разбиения с учетом условий <math>(1)</math> и <math>(2)</math>

3) Рассчитываем центроиды (центры кластеров): <math>V_j = {{\sum_{i=1}^M w_{ij}^m * X_i} \over {\sum_{i=1}^M w_{ij}^m}}, j = 1, ..., c</math>

4) Рассчитываем расстояния между объектами <math>X</math> и центроидами:

<math>D_{ij} = {||X_i - V_j||}, i = 1,...,M; j = 1,...,c </math>

5) Пересчет элементов матрицы разбиения:

при <math>D_{ij} >0</math> : <math>w_{ij} = {{1}\over {{ (\sum_{k=1}^c {{D_{ij}}\over{D_{ik}}} ) }^{2/(m-1)}}}, j = 1,...,c</math>

при <math>D_{ij} =0</math> : <math>w_{ij} = \delta_{ij}, j = 1,...,c</math>, где <math>\delta_{ij}</math> - символ Кронекера

6) Если <math>|| F - F^{*} || < \varepsilon </math>, где <math>F^{*}</math> - матрица нечеткого разбиения предыдущей итерации, то идем далее, иначе возвращаемся на пункт 3.

7) Конец.

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

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

* Поиск <math>V_j</math> - расчет центроидов (пункт 3 алгоритма)
* Нахождение <math>D_{ij}</math> - расстояний между объектами (пункт 4 алгоритма)
* Пересчет <math>w_{ij}</math> - элементов матрицы разбиения (пункт 5 алгоритма)

== Макроструктура алгоритма ==
Основные шаги при реализации алгоритма
* Генерация случайной матрицы размера <math>M*c</math>, проверка условий
* Расчет центроидов – по сути, скалярное произведение с нормировкой
* Расчет расстояний – в общепринятом случае является скалярным произведением
* Пересчет матрицы – по сути, скалярное произведение
* Проверка условий останова – вычисление нормы

== Схема реализации последовательного алгоритма ==
float ** FuzzyCMeans (float** X, c, m, eps){
n = X.size();
r = X[0].size();
centers = generateZeroFill(c, r)
Wprev = genetateRandFill(n, c);
W = Wprev;
while (true){
// обновляем центры кластеров
for (int i=0; i<c; i++){
float * num = new float []();
float den = 0;
for (int j=0; j<n; j++){
num += pow(W[j][i], m) * X[j];
den+=pow(W[j][i], m);
}
centers[i] = num / den;
}
//обновляем вероятности W и считаем расстояние между матрицами W и Wprev
float max_diff = 0;
for (int i=0; i<n; i++)
for (int j=0; j<c; j++){
total = 0;
for (int m=0; m<с; m++)
total += pow(distance(X[i], centers[j]) / distance(X[i], centers[m]), 2/(m-1));
W[i][j] = 1/total;
max_diff = max(abs(Wprev[i][j]-W[i][j]), max_diff);
Wprev[i][j] = W[i][j];
}
if (max_diff < eps):
break;
}
return W;
}

== Последовательная сложность алгоритма ==
Последовательная сложность алгоритма состоит из сложности каждой итерации умноженной на их количество. Так как число итераций заранее неизвестно и зависит от входных параметров, рассмотрим сложность на каждой итерации. Наибольшую сложность представляет собой пересчет матрицы, сложность которого <math>O(c^2 nd)</math> (по сравнению со сложностью <math>O(cnd)</math> расчета расстояний, вычисления центроидов и проверки условия останова). Итого общая сложность алгоритма <math>O(c^2 ndi)</math>

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

'''Первый ярус''' состоит из <math>M</math> параллельных операций 1, 2, совершаемых в цикле <math>c</math> раз для каждого кластера.

'''Операция 1''': <math>w_{ij}^m</math>, где <math>j</math> - номер итерации в цикле, <math>i</math> - номер параллельной ветви.

'''Операция 2''': <math>w_{ij}^m*X_i</math>

Здесь <math>j</math> - номер итерации в цикле, <math>i</math> - номер параллельной ветви.

На выходе из каждой ветки получаем вектор размера <math>1</math> x <math>c</math> и матрицу размера <math>d</math> x <math>c</math>.
Далее совершаем поэлементное сложение векторов и матриц соответственно, а затем делим каждый столбец в матрице на соответствующий элемент в векторе.

'''Второй ярус''' состоит их <math>M</math> параллельных операций 3, 4, 5 также совершаемых в цикле <math>c</math> раз.

'''Операция 3''': обновление значения <math>w_{ij}</math> по указанной в разделе 1.2 в пункте 5 формуле.

'''Операция 4''': <math>maximum = max(|w_{ij} - w_{ij}^{prev}|, maximum)</math>.

'''Операция 5''': <math>w_{ij}^{prev} = w_{ij}</math>.

Здесь <math>j</math> - номер итерации в цикле, <math>i</math> - номер параллельной ветви.

На выходе из каждой ветки получаем число <math>maximum</math>. Далее находим максимальное значение из полученных величин для каждой ветки. Затем проверяем условие останова алгоритма.

[[File:Scheme3.JPG]]

== Ресурс параллелизма алгоритма ==
Параллельная сложность алгоритма: <math>M*c^2*i</math>. Такая сложность получается за счет распараллеливания на каждом ярусе <math>M</math> операций. Иерархическая структура параллелизма подробно описана в [[#Информационный граф|п.1.7]].

В алгоритме не возникает скошенного параллелизма.

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

* Входные данные алгоритма: набор векторов <math>x_i</math> размерности <math>d</math>, где <math>i = 1,...,M</math>; <math>M</math> - количество векторов.
* Объем входных данных: <math>M*d</math> , [количество наблюдений * размерность].
* Выходные данные алгоритма: матрица вероятностей принадлежности векторов кластерам <math>M</math> на <math>c</math>.
* Объем выходных данных: <math>M*c</math> , [количество наблюдений * количество кластеров].

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

* Соотношение последовательной и параллельной формы алгоритма: <math>M</math>
* Вычислительная мощность: <math>{dc^2i} \over {c+d}</math>.
* Устойчивость: алгоритм не является устойчивым, поэтому существует много исследований о том, как первоначально выбрать параметры кластеризации.
* Сбалансированность: в данном алгоритме операция умножения доминирует над операцией сложения. Операции между параллельными ветвями сбалансированны.
* Детерминированность: алгоритм не является детерминированным, так как матрица нечеткого разбиение генерируется произвольно.
* Степень исхода вершины информационного графа ( для одной интерации): 2 (3 - с учетом, если выходные данные пошли на следующую итерацию).

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

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

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

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

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

Проведём исследование масштабируемости параллельной реализации нечеткого алгоритма С-средних.
Исследование проводилось на суперкомпьютере "Ломоносов"<ref name="Lom">Воеводин Вл., Жуматий С., Соболев С., Антонов А., Брызгалов П., Никитенко Д., Стефанов К., Воеводин Вад. Практика суперкомпьютера «Ломоносов» // Открытые системы, 2012, N 7, С. 36-39.</ref> [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета].
Была исследована собственная параллельная реализация алгоритма, написанная на языке C++ с использованием стандарта MPI. Сборка программы производилась при помощи компилятора компании Intel версии 13.1.0 с использованием библиотеки intelMPI версии 4.1.0 . Расчеты проводились в разделе test на узлах со следующими характеристиками: количество GPU - 0, количество ядер - 8 ядер архитектуры x86, количество памяти - 12 Гб.

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

* число процессоров [1 : 128];
* размер матрицы [10000 : 80000].

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

* минимальная эффективность реализации 0,33%;
* максимальная эффективность реализации 9,4%.

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

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

Построим оценки масштабируемости выбранной реализации нечеткого алгоритма С-средних:
* По числу процессов: 0.007. При увеличении числа процессов эффективность на рассмотренной области изменений параметров запуска увеличивается.
* По размеру задачи: -0.0016. При увеличении размера задачи эффективность уменьшается.
* По двум направлениям: 0,000077. При рассмотрении увеличения как вычислительной сложности, так и числа процессов на всей рассмотренной области значений эффективность увеличивается, однако скорость увеличения эффективности небольшая.

Была использована следующая реализация алгоритма.

#include <mpi.h>
#include <stdio.h>
#include <iostream>
#include <stdlib.h>
#include <math.h>
#include <string.h>
#include <time.h>
using namespace std;
double **x; //input matrix of size (n x x_dim)
int n;
int x_dim;
double **centroids; //cluster centroids matrix of size (n_cluster x x_dim)
int n_cluster; // number of clusters
double **w; //probability matrix of size (n x n_cluster)
double **dist; //distances matrix of size (n x n_cluster)
double eps; //max error
double m; //parameter of algo
int max_iter; // max num of iterations
double **num;
double *den;
double *allden;
double *err;
double *total_err;
int rank, size;
double ** generateZerosMatrix(int r, int c){
double ** arr = new double* [r];
for (int i = 0; i < r; ++i){
arr[i] = new double[c]();
}
return arr;
}
int generate_data()
{
//generate matrix
x = generateZerosMatrix(n, x_dim);
centroids = generateZerosMatrix(n_cluster, x_dim);
w = generateZerosMatrix(n, n_cluster);
dist = generateZerosMatrix(n, n_cluster);
num = generateZerosMatrix(n_cluster, x_dim);
//generate vectors
den = new double [n_cluster]();
allden = new double [n_cluster]();
//for stopping algorithm
err = new double;
total_err = new double;
srand(time(0));
//initialize w randomly with restrictions
for (int i = 0; i < n; ++i){
double sum = 0;
for (int j = 0; j < n_cluster; ++j){
w[i][j] = rand();
sum += w[i][j];
}
for (int j = 0; j < n_cluster; ++j){
w[i][j] /= sum;
}
}
//initialize x randomly
for (int i = 0; i < n; ++i)
for (int j = 0; j < x_dim; ++j)
x[i][j] = rand();
return 0;
}
double make_iteration() {
// calculate centroids centers
for (int i = rank; i < n; i+=size)
for (int j = 0; j < n_cluster; ++j){
double mu = pow(w[i][j], m);
den[j] += mu;
for (int k = 0; k < x_dim; ++k)
num[j][k] = mu * x[i][k];
}
MPI_Allreduce(den, allden, n_cluster, MPI_DOUBLE, MPI_SUM, MPI_COMM_WORLD);
for (int j=0; j < n_cluster; ++j)
MPI_Allreduce(num[j], centroids[j], x_dim, MPI_DOUBLE, MPI_SUM, MPI_COMM_WORLD);
for (int i = 0; i < n_cluster; ++i)
for (int j = 0; j < x_dim; ++j)
centroids[i][j] /= allden[i];
// calculate distances and probabilities, check stop conditions
double err = 0.0;
for (int i = rank; i < n; i+=size)
for (int j = 0; j < n_cluster; ++j){
for (int k = 0; k < x_dim; ++k)
dist[i][j] += (x[i][k] - centroids[j][k]) * (x[i][k] - centroids[j][k]);
double w_prev = w[i][j];
for (int k = 0; k < n_cluster; ++k)
w[i][j] += dist[i][j] / dist[i][k];
w[i][j] = 1.0 / pow(w[i][j], 1.0 / (m - 1));
err = fmax(err, abs(w_prev - w[i][j]));
}
return err;
}
int FCM(){
*total_err = eps+1;
int cur_iter = 0;
while (cur_iter < max_iter && *total_err > eps){
*err = make_iteration();
MPI_Allreduce(err, total_err, 1, MPI_DOUBLE, MPI_MAX, MPI_COMM_WORLD);
cur_iter++;
}
return cur_iter;
}
void clearMatrix(double ** matr, int r, int c){
for (int i = 0; i < r; ++i){
delete [] matr[i];
}
delete [] matr;
}
int memory_free(){
clearMatrix(x, n, x_dim);
clearMatrix(centroids, n_cluster, x_dim);
clearMatrix(w, n_cluster, n);
clearMatrix(num, n_cluster, x_dim);
clearMatrix(dist, n, n_cluster);
delete [] den;
delete [] allden;
delete err;
delete total_err;
return 0;
}
int main(int argc, char **argv){
MPI_Init(&argc, &argv);
MPI_Comm_size(MPI_COMM_WORLD, &size);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
int n_repeat = strtol(argv[1], NULL, 10);
int nx_min = strtol(argv[2], NULL, 10);
int nx_max = strtol(argv[3], NULL, 10);
int step = strtol(argv[4], NULL, 10);
x_dim = strtol(argv[5], NULL, 10);
m = strtod(argv[6], NULL);
n_cluster = strtol(argv[7], NULL, 10);
max_iter = strtol(argv[8], NULL, 10);
eps = strtod(argv[9], NULL);
//for all input matrix sizes
for (n = nx_min; n <= nx_max; n += step){
double start, finish, time_elapsed_iter=0;
int total_iterations = 0;
//repeat for getting mean value
for (int i = 0; i < n_repeat; ++i) {
generate_data();
MPI_Barrier(MPI_COMM_WORLD);
start = MPI_Wtime();
total_iterations += FCM();
finish = MPI_Wtime();
memory_free();
time_elapsed_iter += (finish-start);
}
time_elapsed_iter /= total_iterations;
if (rank == 0) {
cout << n << " " << size << " " << time_elapsed_iter << endl;
}
}
MPI_Finalize();
}

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

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

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

* Реализация алгоритма на POSTGRESQL: http://num-meth.srcc.msu.ru/zhurnal/tom_2012/pdf/v13r207.pdf
* Библиотека для MATLAB: http://www.mathworks.com/help/fuzzy/fcm.html (распространяется на коммерческой основе)

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

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

2016-12-18T20:00:53Z

Yushin:

{{Assignment|{{REVISIONUSER}}}}

{{algorithm
| name = Нечеткий алгоритм C средних
| serial_complexity = <math>O(Mdc^2i)</math>, <math>i</math> - количество итераций
| input_data = <math>M*d</math>, [количество наблюдений * размерность]
| output_data = <math>M*c</math>, [количество наблюдений * количество кластеров]
| pf_height = <math>2i</math>
| pf_width = <math>n</math>
}}

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

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

== Общее описание алгоритма ==
Кластеризация - это объединение объектов в группы (кластеры) на основе схожести признаков для объектов одной группы и отличий между группами. Нечеткий алгоритм C Средних (Fuzzy C-means, FCM) - алгоритм кластеризации, позволяющий объектам принадлежать с различной степенью нескольким кластерам одновременно. Впервые алгоритм был предложен J.C. Dunn в 1973 <ref>[http://www.tandfonline.com/doi/abs/10.1080/01969727308546046 | J. C. Dunn. A Fuzzy Relative of the ISODATA Process and Its Use in Detecting Compact Well-Separated Clusters. Journal of Cybernetics, volume 3,1973 - Issue 3, pp 32-57]</ref>. Нечеткое разбиение позволяет просто решить проблему объектов кластеризации, расположенных на границе двух кластеров - им назначают степени принадлежностей равные 0.5.

Входные данные алгоритма: набор векторов, которые следует кластеризовать.

Параметры алгоритма: <math>c</math> - количество кластеров;<math>m >= 1</math> - экспоненциальный вес, определяющий нечеткость кластеров; <math>\varepsilon</math> - параметр останова алгоритма.

Выходные данные: матрица вероятностей принадлежности векторов кластерам.

Краткое описание алгоритма:

* Задать параметры алгоритма.

* Сгенерировать случайную матрицу принадлежностей векторов кластерам (матрицу нечеткого разбиения).

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

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

Пусть <math> W = w_{ij} \in[0,1],\; i = 1, ..., M, \; j = 1, ..., c</math> - матрица разбиения, где <math>w_{i,j}</math> - степень принадлежности объекта <math>i</math> к кластеру <math>j</math>; <math>c</math> - количество кластеров, <math>M</math> - количество векторов, <math>X_i</math> - набор входных векторов размерности <math>d</math>.

В качестве нормы предлагается максимум-норм: <math>||W|| = max_i,j |w_i,j|</math>

При этом элементы матрицы должны удовлетворять условиям:

* <math>\sum_{j = 1}^c w_{ij} = 1, i = 1, ..., M</math>                <math>(1)</math>
* <math>0 < \sum_{i = 1}^M w_{ij} < M, j = 1, ..., c</math>       <math>(2)</math>

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

1) Задаем параметры алгоритма: <math>c</math> - количество кластеров; <math>m >= 1</math> - экспоненциальный вес, определяющий нечеткость кластеров; <math>\varepsilon > 0</math> - параметр останова алгоритма.

2) Генерируем случайным образом матрицу нечеткого разбиения с учетом условий <math>(1)</math> и <math>(2)</math>

3) Рассчитываем центроиды (центры кластеров): <math>V_j = {{\sum_{i=1}^M w_{ij}^m * X_i} \over {\sum_{i=1}^M w_{ij}^m}}, j = 1, ..., c</math>

4) Рассчитываем расстояния между объектами <math>X</math> и центроидами:

<math>D_{ij} = {||X_i - V_j||}, i = 1,...,M; j = 1,...,c </math>

5) Пересчет элементов матрицы разбиения:

при <math>D_{ij} >0</math> : <math>w_{ij} = {{1}\over {{ (\sum_{k=1}^c {{D_{ij}}\over{D_{ik}}} ) }^{2/(m-1)}}}, j = 1,...,c</math>

при <math>D_{ij} =0</math> : <math>w_{ij} = \delta_{ij}, j = 1,...,c</math>, где <math>\delta_{ij}</math> - символ Кронекера

6) Если <math>|| F - F^{*} || < \varepsilon </math>, где <math>F^{*}</math> - матрица нечеткого разбиения предыдущей итерации, то идем далее, иначе возвращаемся на пункт 3.

7) Конец.

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

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

* Поиск <math>V_j</math> - расчет центроидов (пункт 3 алгоритма)
* Нахождение <math>D_{ij}</math> - расстояний между объектами (пункт 4 алгоритма)
* Пересчет <math>w_{ij}</math> - элементов матрицы разбиения (пункт 5 алгоритма)

== Макроструктура алгоритма ==
Основные шаги при реализации алгоритма
* Генерация случайной матрицы размера <math>M*c</math>, проверка условий
* Расчет центроидов – по сути, скалярное произведение с нормировкой
* Расчет расстояний – в общепринятом случае является скалярным произведением
* Пересчет матрицы – по сути, скалярное произведение
* Проверка условий останова – вычисление нормы

== Схема реализации последовательного алгоритма ==
float ** FuzzyCMeans (float** X, c, m, eps){
n = X.size();
r = X[0].size();
centers = generateZeroFill(c, r)
Wprev = genetateRandFill(n, c);
W = Wprev;
while (true){
// обновляем центры кластеров
for (int i=0; i<c; i++){
float * num = new float []();
float den = 0;
for (int j=0; j<n; j++){
num += pow(W[j][i], m) * X[j];
den+=pow(W[j][i], m);
}
centers[i] = num / den;
}
//обновляем вероятности W и считаем расстояние между матрицами W и Wprev
float max_diff = 0;
for (int i=0; i<n; i++)
for (int j=0; j<c; j++){
total = 0;
for (int m=0; m<с; m++)
total += pow(distance(X[i], centers[j]) / distance(X[i], centers[m]), 2/(m-1));
W[i][j] = 1/total;
max_diff = max(abs(Wprev[i][j]-W[i][j]), max_diff);
Wprev[i][j] = W[i][j];
}
if (max_diff < eps):
break;
}
return W;
}

== Последовательная сложность алгоритма ==
Последовательная сложность алгоритма состоит из сложности каждой итерации умноженной на их количество. Так как число итераций заранее неизвестно и зависит от входных параметров, рассмотрим сложность на каждой итерации. Наибольшую сложность представляет собой пересчет матрицы, сложность которого <math>O(c^2 nd)</math> (по сравнению со сложностью <math>O(cnd)</math> расчета расстояний, вычисления центроидов и проверки условия останова). Итого общая сложность алгоритма <math>O(c^2 ndi)</math>

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

'''Первый ярус''' состоит из <math>M</math> параллельных операций 1, 2, совершаемых в цикле <math>c</math> раз для каждого кластера.

'''Операция 1''': <math>w_{ij}^m</math>, где <math>j</math> - номер итерации в цикле, <math>i</math> - номер параллельной ветви.

'''Операция 2''': <math>w_{ij}^m*X_i</math>

Здесь <math>j</math> - номер итерации в цикле, <math>i</math> - номер параллельной ветви.

На выходе из каждой ветки получаем вектор размера <math>1</math> x <math>c</math> и матрицу размера <math>d</math> x <math>c</math>.
Далее совершаем поэлементное сложение векторов и матриц соответственно, а затем делим каждый столбец в матрице на соответствующий элемент в векторе.

'''Второй ярус''' состоит их <math>M</math> параллельных операций 3, 4, 5 также совершаемых в цикле <math>c</math> раз.

'''Операция 3''': обновление значения <math>w_{ij}</math> по указанной в разделе 1.2 в пункте 5 формуле.

'''Операция 4''': <math>maximum = max(|w_{ij} - w_{ij}^{prev}|, maximum)</math>.

'''Операция 5''': <math>w_{ij}^{prev} = w_{ij}</math>.

Здесь <math>j</math> - номер итерации в цикле, <math>i</math> - номер параллельной ветви.

На выходе из каждой ветки получаем число <math>maximum</math>. Далее находим максимальное значение из полученных величин для каждой ветки. Затем проверяем условие останова алгоритма.

[[File:Scheme3.JPG]]

== Ресурс параллелизма алгоритма ==
Параллельная сложность алгоритма: <math>M*c^2*i</math>. Такая сложность получается за счет распараллеливания на каждом ярусе <math>M</math> операций. Иерархическая структура параллелизма подробно описана в [[#Информационный граф|п.1.7]].

В алгоритме не возникает скошенного параллелизма.

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

* Входные данные алгоритма: набор векторов <math>x_i</math> размерности <math>d</math>, где <math>i = 1,...,M</math>; <math>M</math> - количество векторов.
* Объем входных данных: <math>M*d</math> , [количество наблюдений * размерность].
* Выходные данные алгоритма: матрица вероятностей принадлежности векторов кластерам <math>M</math> на <math>c</math>.
* Объем выходных данных: <math>M*c</math> , [количество наблюдений * количество кластеров].

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

* Соотношение последовательной и параллельной формы алгоритма: <math>M</math>
* Вычислительная мощность: <math>{dc^2i} \over {c+d}</math>.
* Устойчивость: алгоритм не является устойчивым, поэтому существует много исследований о том, как первоначально выбрать параметры кластеризации.
* Сбалансированность: в данном алгоритме операция умножения доминирует над операцией сложения. Операции между параллельными ветвями сбалансированны.
* Детерминированность: алгоритм не является детерминированным, так как матрица нечеткого разбиение генерируется произвольно.
* Степень исхода вершины информационного графа ( для одной интерации): 2 (3 - с учетом, если выходные данные пошли на следующую итерацию).

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

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

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

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

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

Проведём исследование масштабируемости параллельной реализации нечеткого алгоритма С-средних.
Исследование проводилось на суперкомпьютере "Ломоносов"<ref name="Lom">Воеводин Вл., Жуматий С., Соболев С., Антонов А., Брызгалов П., Никитенко Д., Стефанов К., Воеводин Вад. Практика суперкомпьютера «Ломоносов» // Открытые системы, 2012, N 7, С. 36-39.</ref> [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета].
Была исследована собственная параллельная реализация алгоритма, написанная на языке C++ с использованием стандарта MPI. Сборка программы производилась при помощи компилятора компании Intel версии 13.1.0 с использованием библиотеки intelMPI версии 4.1.0 . Расчеты проводились в разделе test на узлах со следующими характеристиками: количество GPU - 0, количество ядер - 8 ядер архитектуры x86, количество памяти - 12 Гб.

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

* число процессоров [1 : 128];
* размер матрицы [10000 : 80000].

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

* минимальная эффективность реализации 0,33%;
* максимальная эффективность реализации 9,4%.

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

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

Построим оценки масштабируемости выбранной реализации нечеткого алгоритма С-средних:
* По числу процессов: 0.007. При увеличении числа процессов эффективность на рассмотренной области изменений параметров запуска увеличивается.
* По размеру задачи: -0.0016. При увеличении размера задачи эффективность уменьшается.
* По двум направлениям: 0,000077. При рассмотрении увеличения как вычислительной сложности, так и числа процессов на всей рассмотренной области значений эффективность увеличивается, однако скорость увеличения эффективности небольшая.

Была использована следующая реализация алгоритма.

#include <mpi.h>
#include <stdio.h>
#include <iostream>
#include <stdlib.h>
#include <math.h>
#include <string.h>
#include <time.h>
using namespace std;
double **x; //input matrix of size (n x x_dim)
int n;
int x_dim;
double **centroids; //cluster centroids matrix of size (n_cluster x x_dim)
int n_cluster; // number of clusters
double **w; //probability matrix of size (n x n_cluster)
double **dist; //distances matrix of size (n x n_cluster)
double eps; //max error
double m; //parameter of algo
int max_iter; // max num of iterations
double **num;
double *den;
double *allden;
double *err;
double *total_err;
int rank, size;
double ** generateZerosMatrix(int r, int c){
double ** arr = new double* [r];
for (int i = 0; i < r; ++i){
arr[i] = new double[c]();
}
return arr;
}
int generate_data()
{
//generate matrix
x = generateZerosMatrix(n, x_dim);
centroids = generateZerosMatrix(n_cluster, x_dim);
w = generateZerosMatrix(n, n_cluster);
dist = generateZerosMatrix(n, n_cluster);
num = generateZerosMatrix(n_cluster, x_dim);
//generate vectors
den = new double [n_cluster]();
allden = new double [n_cluster]();
//for stopping algorithm
err = new double;
total_err = new double;
srand(time(0));
//initialize w randomly with restrictions
for (int i = 0; i < n; ++i){
double sum = 0;
for (int j = 0; j < n_cluster; ++j){
w[i][j] = rand();
sum += w[i][j];
}
for (int j = 0; j < n_cluster; ++j){
w[i][j] /= sum;
}
}
//initialize x randomly
for (int i = 0; i < n; ++i)
for (int j = 0; j < x_dim; ++j)
x[i][j] = rand();
return 0;
}
double make_iteration() {
// calculate centroids centers
for (int i = rank; i < n; i+=size)
for (int j = 0; j < n_cluster; ++j){
double mu = pow(w[i][j], m);
den[j] += mu;
for (int k = 0; k < x_dim; ++k)
num[j][k] = mu * x[i][k];
}
MPI_Allreduce(den, allden, n_cluster, MPI_DOUBLE, MPI_SUM, MPI_COMM_WORLD);
for (int j=0; j < n_cluster; ++j)
MPI_Allreduce(num[j], centroids[j], x_dim, MPI_DOUBLE, MPI_SUM, MPI_COMM_WORLD);
for (int i = 0; i < n_cluster; ++i)
for (int j = 0; j < x_dim; ++j)
centroids[i][j] /= allden[i];
// calculate distances and probabilities, check stop conditions
double err = 0.0;
for (int i = rank; i < n; i+=size)
for (int j = 0; j < n_cluster; ++j){
for (int k = 0; k < x_dim; ++k)
dist[i][j] += (x[i][k] - centroids[j][k]) * (x[i][k] - centroids[j][k]);
double w_prev = w[i][j];
for (int k = 0; k < n_cluster; ++k)
w[i][j] += dist[i][j] / dist[i][k];
w[i][j] = 1.0 / pow(w[i][j], 1.0 / (m - 1));
err = fmax(err, abs(w_prev - w[i][j]));
}
return err;
}
int FCM(){
*total_err = eps+1;
int cur_iter = 0;
while (cur_iter < max_iter && *total_err > eps){
*err = make_iteration();
MPI_Allreduce(err, total_err, 1, MPI_DOUBLE, MPI_MAX, MPI_COMM_WORLD);
cur_iter++;
}
return cur_iter;
}
void clearMatrix(double ** matr, int r, int c){
for (int i = 0; i < r; ++i){
delete [] matr[i];
}
delete [] matr;
}
int memory_free(){
clearMatrix(x, n, x_dim);
clearMatrix(centroids, n_cluster, x_dim);
clearMatrix(w, n_cluster, n);
clearMatrix(num, n_cluster, x_dim);
clearMatrix(dist, n, n_cluster);
delete [] den;
delete [] allden;
delete err;
delete total_err;
return 0;
}
int main(int argc, char **argv){
MPI_Init(&argc, &argv);
MPI_Comm_size(MPI_COMM_WORLD, &size);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
int n_repeat = strtol(argv[1], NULL, 10);
int nx_min = strtol(argv[2], NULL, 10);
int nx_max = strtol(argv[3], NULL, 10);
int step = strtol(argv[4], NULL, 10);
x_dim = strtol(argv[5], NULL, 10);
m = strtod(argv[6], NULL);
n_cluster = strtol(argv[7], NULL, 10);
max_iter = strtol(argv[8], NULL, 10);
eps = strtod(argv[9], NULL);
//for all input matrix sizes
for (n = nx_min; n <= nx_max; n += step){
double start, finish, time_elapsed_iter=0;
int total_iterations = 0;
//repeat for getting mean value
for (int i = 0; i < n_repeat; ++i) {
generate_data();
MPI_Barrier(MPI_COMM_WORLD);
start = MPI_Wtime();
total_iterations += FCM();
finish = MPI_Wtime();
memory_free();
time_elapsed_iter += (finish-start);
}
time_elapsed_iter /= total_iterations;
if (rank == 0) {
cout << n << " " << size << " " << time_elapsed_iter << endl;
}
}
MPI_Finalize();
}

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

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

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

* Реализация алгоритма на POSTGRESQL: http://num-meth.srcc.msu.ru/zhurnal/tom_2012/pdf/v13r207.pdf
* Библиотека для MATLAB: http://www.mathworks.com/help/fuzzy/fcm.html (распространяется на коммерческой основе)

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

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

2016-12-18T20:00:32Z

Yushin:

{{Assignment|{{REVISIONUSER}}}}

{{algorithm
| name = Нечеткий алгоритм C средних
| serial_complexity = <math>O(Mdc^2i)</math>, <math>i</math> - количество итераций
| input_data = <math>M*d</math>, [количество наблюдений * размерность]
| output_data = <math>M*c</math>, [количество наблюдений * количество кластеров]
| pf_height = <math>2i</math>
| pf_width = <math>n</math>
}}

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

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

== Общее описание алгоритма ==
Кластеризация - это объединение объектов в группы (кластеры) на основе схожести признаков для объектов одной группы и отличий между группами. Нечеткий алгоритм C Средних (Fuzzy C-means, FCM) - алгоритм кластеризации, позволяющий объектам принадлежать с различной степенью нескольким кластерам одновременно. Впервые алгоритм был предложен J.C. Dunn в 1973 <ref>[http://www.tandfonline.com/doi/abs/10.1080/01969727308546046 | J. C. Dunn. A Fuzzy Relative of the ISODATA Process and Its Use in Detecting Compact Well-Separated Clusters. Journal of Cybernetics, volume 3,1973 - Issue 3, pp 32-57]</ref>. Нечеткое разбиение позволяет просто решить проблему объектов кластеризации, расположенных на границе двух кластеров - им назначают степени принадлежностей равные 0.5.

Входные данные алгоритма: набор векторов, которые следует кластеризовать.

Параметры алгоритма: <math>c</math> - количество кластеров;<math>m >= 1</math> - экспоненциальный вес, определяющий нечеткость кластеров; <math>\varepsilon</math> - параметр останова алгоритма.

Выходные данные: матрица вероятностей принадлежности векторов кластерам.

Краткое описание алгоритма:

* Задать параметры алгоритма.

* Сгенерировать случайную матрицу принадлежностей векторов кластерам (матрицу нечеткого разбиения).

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

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

Пусть <math> W = w_{ij} \in[0,1],\; i = 1, ..., M, \; j = 1, ..., c</math> - матрица разбиения, где <math>w_{i,j}</math> - степень принадлежности объекта <math>i</math> к кластеру <math>j</math>; <math>c</math> - количество кластеров, <math>M</math> - количество векторов, <math>X_i</math> - набор входных векторов размерности <math>d</math>.

В качестве нормы предлагается максимум-норм: <math> ||W|| = max_i,j |w_i,j|

При этом элементы матрицы должны удовлетворять условиям:

* <math>\sum_{j = 1}^c w_{ij} = 1, i = 1, ..., M</math>                <math>(1)</math>
* <math>0 < \sum_{i = 1}^M w_{ij} < M, j = 1, ..., c</math>       <math>(2)</math>

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

1) Задаем параметры алгоритма: <math>c</math> - количество кластеров; <math>m >= 1</math> - экспоненциальный вес, определяющий нечеткость кластеров; <math>\varepsilon > 0</math> - параметр останова алгоритма.

2) Генерируем случайным образом матрицу нечеткого разбиения с учетом условий <math>(1)</math> и <math>(2)</math>

3) Рассчитываем центроиды (центры кластеров): <math>V_j = {{\sum_{i=1}^M w_{ij}^m * X_i} \over {\sum_{i=1}^M w_{ij}^m}}, j = 1, ..., c</math>

4) Рассчитываем расстояния между объектами <math>X</math> и центроидами:

<math>D_{ij} = {||X_i - V_j||}, i = 1,...,M; j = 1,...,c </math>

5) Пересчет элементов матрицы разбиения:

при <math>D_{ij} >0</math> : <math>w_{ij} = {{1}\over {{ (\sum_{k=1}^c {{D_{ij}}\over{D_{ik}}} ) }^{2/(m-1)}}}, j = 1,...,c</math>

при <math>D_{ij} =0</math> : <math>w_{ij} = \delta_{ij}, j = 1,...,c</math>, где <math>\delta_{ij}</math> - символ Кронекера

6) Если <math>|| F - F^{*} || < \varepsilon </math>, где <math>F^{*}</math> - матрица нечеткого разбиения предыдущей итерации, то идем далее, иначе возвращаемся на пункт 3.

7) Конец.

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

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

* Поиск <math>V_j</math> - расчет центроидов (пункт 3 алгоритма)
* Нахождение <math>D_{ij}</math> - расстояний между объектами (пункт 4 алгоритма)
* Пересчет <math>w_{ij}</math> - элементов матрицы разбиения (пункт 5 алгоритма)

== Макроструктура алгоритма ==
Основные шаги при реализации алгоритма
* Генерация случайной матрицы размера <math>M*c</math>, проверка условий
* Расчет центроидов – по сути, скалярное произведение с нормировкой
* Расчет расстояний – в общепринятом случае является скалярным произведением
* Пересчет матрицы – по сути, скалярное произведение
* Проверка условий останова – вычисление нормы

== Схема реализации последовательного алгоритма ==
float ** FuzzyCMeans (float** X, c, m, eps){
n = X.size();
r = X[0].size();
centers = generateZeroFill(c, r)
Wprev = genetateRandFill(n, c);
W = Wprev;
while (true){
// обновляем центры кластеров
for (int i=0; i<c; i++){
float * num = new float []();
float den = 0;
for (int j=0; j<n; j++){
num += pow(W[j][i], m) * X[j];
den+=pow(W[j][i], m);
}
centers[i] = num / den;
}
//обновляем вероятности W и считаем расстояние между матрицами W и Wprev
float max_diff = 0;
for (int i=0; i<n; i++)
for (int j=0; j<c; j++){
total = 0;
for (int m=0; m<с; m++)
total += pow(distance(X[i], centers[j]) / distance(X[i], centers[m]), 2/(m-1));
W[i][j] = 1/total;
max_diff = max(abs(Wprev[i][j]-W[i][j]), max_diff);
Wprev[i][j] = W[i][j];
}
if (max_diff < eps):
break;
}
return W;
}

== Последовательная сложность алгоритма ==
Последовательная сложность алгоритма состоит из сложности каждой итерации умноженной на их количество. Так как число итераций заранее неизвестно и зависит от входных параметров, рассмотрим сложность на каждой итерации. Наибольшую сложность представляет собой пересчет матрицы, сложность которого <math>O(c^2 nd)</math> (по сравнению со сложностью <math>O(cnd)</math> расчета расстояний, вычисления центроидов и проверки условия останова). Итого общая сложность алгоритма <math>O(c^2 ndi)</math>

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

'''Первый ярус''' состоит из <math>M</math> параллельных операций 1, 2, совершаемых в цикле <math>c</math> раз для каждого кластера.

'''Операция 1''': <math>w_{ij}^m</math>, где <math>j</math> - номер итерации в цикле, <math>i</math> - номер параллельной ветви.

'''Операция 2''': <math>w_{ij}^m*X_i</math>

Здесь <math>j</math> - номер итерации в цикле, <math>i</math> - номер параллельной ветви.

На выходе из каждой ветки получаем вектор размера <math>1</math> x <math>c</math> и матрицу размера <math>d</math> x <math>c</math>.
Далее совершаем поэлементное сложение векторов и матриц соответственно, а затем делим каждый столбец в матрице на соответствующий элемент в векторе.

'''Второй ярус''' состоит их <math>M</math> параллельных операций 3, 4, 5 также совершаемых в цикле <math>c</math> раз.

'''Операция 3''': обновление значения <math>w_{ij}</math> по указанной в разделе 1.2 в пункте 5 формуле.

'''Операция 4''': <math>maximum = max(|w_{ij} - w_{ij}^{prev}|, maximum)</math>.

'''Операция 5''': <math>w_{ij}^{prev} = w_{ij}</math>.

Здесь <math>j</math> - номер итерации в цикле, <math>i</math> - номер параллельной ветви.

На выходе из каждой ветки получаем число <math>maximum</math>. Далее находим максимальное значение из полученных величин для каждой ветки. Затем проверяем условие останова алгоритма.

[[File:Scheme3.JPG]]

== Ресурс параллелизма алгоритма ==
Параллельная сложность алгоритма: <math>M*c^2*i</math>. Такая сложность получается за счет распараллеливания на каждом ярусе <math>M</math> операций. Иерархическая структура параллелизма подробно описана в [[#Информационный граф|п.1.7]].

В алгоритме не возникает скошенного параллелизма.

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

* Входные данные алгоритма: набор векторов <math>x_i</math> размерности <math>d</math>, где <math>i = 1,...,M</math>; <math>M</math> - количество векторов.
* Объем входных данных: <math>M*d</math> , [количество наблюдений * размерность].
* Выходные данные алгоритма: матрица вероятностей принадлежности векторов кластерам <math>M</math> на <math>c</math>.
* Объем выходных данных: <math>M*c</math> , [количество наблюдений * количество кластеров].

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

* Соотношение последовательной и параллельной формы алгоритма: <math>M</math>
* Вычислительная мощность: <math>{dc^2i} \over {c+d}</math>.
* Устойчивость: алгоритм не является устойчивым, поэтому существует много исследований о том, как первоначально выбрать параметры кластеризации.
* Сбалансированность: в данном алгоритме операция умножения доминирует над операцией сложения. Операции между параллельными ветвями сбалансированны.
* Детерминированность: алгоритм не является детерминированным, так как матрица нечеткого разбиение генерируется произвольно.
* Степень исхода вершины информационного графа ( для одной интерации): 2 (3 - с учетом, если выходные данные пошли на следующую итерацию).

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

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

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

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

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

Проведём исследование масштабируемости параллельной реализации нечеткого алгоритма С-средних.
Исследование проводилось на суперкомпьютере "Ломоносов"<ref name="Lom">Воеводин Вл., Жуматий С., Соболев С., Антонов А., Брызгалов П., Никитенко Д., Стефанов К., Воеводин Вад. Практика суперкомпьютера «Ломоносов» // Открытые системы, 2012, N 7, С. 36-39.</ref> [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета].
Была исследована собственная параллельная реализация алгоритма, написанная на языке C++ с использованием стандарта MPI. Сборка программы производилась при помощи компилятора компании Intel версии 13.1.0 с использованием библиотеки intelMPI версии 4.1.0 . Расчеты проводились в разделе test на узлах со следующими характеристиками: количество GPU - 0, количество ядер - 8 ядер архитектуры x86, количество памяти - 12 Гб.

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

* число процессоров [1 : 128];
* размер матрицы [10000 : 80000].

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

* минимальная эффективность реализации 0,33%;
* максимальная эффективность реализации 9,4%.

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

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

Построим оценки масштабируемости выбранной реализации нечеткого алгоритма С-средних:
* По числу процессов: 0.007. При увеличении числа процессов эффективность на рассмотренной области изменений параметров запуска увеличивается.
* По размеру задачи: -0.0016. При увеличении размера задачи эффективность уменьшается.
* По двум направлениям: 0,000077. При рассмотрении увеличения как вычислительной сложности, так и числа процессов на всей рассмотренной области значений эффективность увеличивается, однако скорость увеличения эффективности небольшая.

Была использована следующая реализация алгоритма.

#include <mpi.h>
#include <stdio.h>
#include <iostream>
#include <stdlib.h>
#include <math.h>
#include <string.h>
#include <time.h>
using namespace std;
double **x; //input matrix of size (n x x_dim)
int n;
int x_dim;
double **centroids; //cluster centroids matrix of size (n_cluster x x_dim)
int n_cluster; // number of clusters
double **w; //probability matrix of size (n x n_cluster)
double **dist; //distances matrix of size (n x n_cluster)
double eps; //max error
double m; //parameter of algo
int max_iter; // max num of iterations
double **num;
double *den;
double *allden;
double *err;
double *total_err;
int rank, size;
double ** generateZerosMatrix(int r, int c){
double ** arr = new double* [r];
for (int i = 0; i < r; ++i){
arr[i] = new double[c]();
}
return arr;
}
int generate_data()
{
//generate matrix
x = generateZerosMatrix(n, x_dim);
centroids = generateZerosMatrix(n_cluster, x_dim);
w = generateZerosMatrix(n, n_cluster);
dist = generateZerosMatrix(n, n_cluster);
num = generateZerosMatrix(n_cluster, x_dim);
//generate vectors
den = new double [n_cluster]();
allden = new double [n_cluster]();
//for stopping algorithm
err = new double;
total_err = new double;
srand(time(0));
//initialize w randomly with restrictions
for (int i = 0; i < n; ++i){
double sum = 0;
for (int j = 0; j < n_cluster; ++j){
w[i][j] = rand();
sum += w[i][j];
}
for (int j = 0; j < n_cluster; ++j){
w[i][j] /= sum;
}
}
//initialize x randomly
for (int i = 0; i < n; ++i)
for (int j = 0; j < x_dim; ++j)
x[i][j] = rand();
return 0;
}
double make_iteration() {
// calculate centroids centers
for (int i = rank; i < n; i+=size)
for (int j = 0; j < n_cluster; ++j){
double mu = pow(w[i][j], m);
den[j] += mu;
for (int k = 0; k < x_dim; ++k)
num[j][k] = mu * x[i][k];
}
MPI_Allreduce(den, allden, n_cluster, MPI_DOUBLE, MPI_SUM, MPI_COMM_WORLD);
for (int j=0; j < n_cluster; ++j)
MPI_Allreduce(num[j], centroids[j], x_dim, MPI_DOUBLE, MPI_SUM, MPI_COMM_WORLD);
for (int i = 0; i < n_cluster; ++i)
for (int j = 0; j < x_dim; ++j)
centroids[i][j] /= allden[i];
// calculate distances and probabilities, check stop conditions
double err = 0.0;
for (int i = rank; i < n; i+=size)
for (int j = 0; j < n_cluster; ++j){
for (int k = 0; k < x_dim; ++k)
dist[i][j] += (x[i][k] - centroids[j][k]) * (x[i][k] - centroids[j][k]);
double w_prev = w[i][j];
for (int k = 0; k < n_cluster; ++k)
w[i][j] += dist[i][j] / dist[i][k];
w[i][j] = 1.0 / pow(w[i][j], 1.0 / (m - 1));
err = fmax(err, abs(w_prev - w[i][j]));
}
return err;
}
int FCM(){
*total_err = eps+1;
int cur_iter = 0;
while (cur_iter < max_iter && *total_err > eps){
*err = make_iteration();
MPI_Allreduce(err, total_err, 1, MPI_DOUBLE, MPI_MAX, MPI_COMM_WORLD);
cur_iter++;
}
return cur_iter;
}
void clearMatrix(double ** matr, int r, int c){
for (int i = 0; i < r; ++i){
delete [] matr[i];
}
delete [] matr;
}
int memory_free(){
clearMatrix(x, n, x_dim);
clearMatrix(centroids, n_cluster, x_dim);
clearMatrix(w, n_cluster, n);
clearMatrix(num, n_cluster, x_dim);
clearMatrix(dist, n, n_cluster);
delete [] den;
delete [] allden;
delete err;
delete total_err;
return 0;
}
int main(int argc, char **argv){
MPI_Init(&argc, &argv);
MPI_Comm_size(MPI_COMM_WORLD, &size);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
int n_repeat = strtol(argv[1], NULL, 10);
int nx_min = strtol(argv[2], NULL, 10);
int nx_max = strtol(argv[3], NULL, 10);
int step = strtol(argv[4], NULL, 10);
x_dim = strtol(argv[5], NULL, 10);
m = strtod(argv[6], NULL);
n_cluster = strtol(argv[7], NULL, 10);
max_iter = strtol(argv[8], NULL, 10);
eps = strtod(argv[9], NULL);
//for all input matrix sizes
for (n = nx_min; n <= nx_max; n += step){
double start, finish, time_elapsed_iter=0;
int total_iterations = 0;
//repeat for getting mean value
for (int i = 0; i < n_repeat; ++i) {
generate_data();
MPI_Barrier(MPI_COMM_WORLD);
start = MPI_Wtime();
total_iterations += FCM();
finish = MPI_Wtime();
memory_free();
time_elapsed_iter += (finish-start);
}
time_elapsed_iter /= total_iterations;
if (rank == 0) {
cout << n << " " << size << " " << time_elapsed_iter << endl;
}
}
MPI_Finalize();
}

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

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

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

* Реализация алгоритма на POSTGRESQL: http://num-meth.srcc.msu.ru/zhurnal/tom_2012/pdf/v13r207.pdf
* Библиотека для MATLAB: http://www.mathworks.com/help/fuzzy/fcm.html (распространяется на коммерческой основе)

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

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

2016-12-18T19:49:52Z

Yushin:

{{Assignment|{{REVISIONUSER}}}}

{{algorithm
| name = Нечеткий алгоритм C средних
| serial_complexity = <math>O(Mdc^2i)</math>, <math>i</math> - количество итераций
| input_data = <math>M*d</math>, [количество наблюдений * размерность]
| output_data = <math>M*c</math>, [количество наблюдений * количество кластеров]
| pf_height = <math>2i</math>
| pf_width = <math>n</math>
}}

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

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

== Общее описание алгоритма ==
Кластеризация - это объединение объектов в группы (кластеры) на основе схожести признаков для объектов одной группы и отличий между группами. Нечеткий алгоритм C Средних (Fuzzy C-means, FCM) - алгоритм кластеризации, позволяющий объектам принадлежать с различной степенью нескольким кластерам одновременно. Впервые алгоритм был предложен J.C. Dunn в 1973 <ref>[http://www.tandfonline.com/doi/abs/10.1080/01969727308546046 | J. C. Dunn. A Fuzzy Relative of the ISODATA Process and Its Use in Detecting Compact Well-Separated Clusters. Journal of Cybernetics, volume 3,1973 - Issue 3, pp 32-57]</ref>. Нечеткое разбиение позволяет просто решить проблему объектов кластеризации, расположенных на границе двух кластеров - им назначают степени принадлежностей равные 0.5.

Входные данные алгоритма: набор векторов, которые следует кластеризовать.

Параметры алгоритма: <math>c</math> - количество кластеров;<math>m >= 1</math> - экспоненциальный вес, определяющий нечеткость кластеров; <math>\varepsilon</math> - параметр останова алгоритма.

Выходные данные: матрица вероятностей принадлежности векторов кластерам.

Краткое описание алгоритма:

* Задать параметры алгоритма.

* Сгенерировать случайную матрицу принадлежностей векторов кластерам (матрицу нечеткого разбиения).

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

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

Пусть <math> W = w_{ij} \in[0,1],\; i = 1, ..., M, \; j = 1, ..., c</math> - матрица разбиения, где <math>w_{i,j}</math> - степень принадлежности объекта <math>i</math> к кластеру <math>j</math>; <math>c</math> - количество кластеров, <math>M</math> - количество векторов, <math>X_i</math> - набор входных векторов размерности <math>d</math>.

При этом элементы матрицы должны удовлетворять условиям:

* <math>\sum_{j = 1}^c w_{ij} = 1, i = 1, ..., M</math>                <math>(1)</math>
* <math>0 < \sum_{i = 1}^M w_{ij} < M, j = 1, ..., c</math>       <math>(2)</math>

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

1) Задаем параметры алгоритма: <math>c</math> - количество кластеров; <math>m >= 1</math> - экспоненциальный вес, определяющий нечеткость кластеров; <math>\varepsilon > 0</math> - параметр останова алгоритма.

2) Генерируем случайным образом матрицу нечеткого разбиения с учетом условий <math>(1)</math> и <math>(2)</math>

3) Рассчитываем центроиды (центры кластеров): <math>V_j = {{\sum_{i=1}^M w_{ij}^m * X_i} \over {\sum_{i=1}^M w_{ij}^m}}, j = 1, ..., c</math>

4) Рассчитываем расстояния между объектами <math>X</math> и центроидами:

<math>D_{ij} = {||X_i - V_j||}, i = 1,...,M; j = 1,...,c </math>

5) Пересчет элементов матрицы разбиения:

при <math>D_{ij} >0</math> : <math>w_{ij} = {{1}\over {{ (\sum_{k=1}^c {{D_{ij}}\over{D_{ik}}} ) }^{2/(m-1)}}}, j = 1,...,c</math>

при <math>D_{ij} =0</math> : <math>w_{ij} = \delta_{ij}, j = 1,...,c</math>, где <math>\delta_{ij}</math> - символ Кронекера

6) Если <math>|| F - F^{*} || < \varepsilon </math>, где <math>F^{*}</math> - матрица нечеткого разбиения предыдущей итерации, то идем далее, иначе возвращаемся на пункт 3.

7) Конец.

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

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

* Поиск <math>V_j</math> - расчет центроидов (пункт 3 алгоритма)
* Нахождение <math>D_{ij}</math> - расстояний между объектами (пункт 4 алгоритма)
* Пересчет <math>w_{ij}</math> - элементов матрицы разбиения (пункт 5 алгоритма)

== Макроструктура алгоритма ==
Основные шаги при реализации алгоритма
* Генерация случайной матрицы размера <math>M*c</math>, проверка условий
* Расчет центроидов – по сути, скалярное произведение с нормировкой
* Расчет расстояний – в общепринятом случае является скалярным произведением
* Пересчет матрицы – по сути, скалярное произведение
* Проверка условий останова – вычисление нормы

== Схема реализации последовательного алгоритма ==
float ** FuzzyCMeans (float** X, c, m, eps){
n = X.size();
r = X[0].size();
centers = generateZeroFill(c, r)
Wprev = genetateRandFill(n, c);
W = Wprev;
while (true){
// обновляем центры кластеров
for (int i=0; i<c; i++){
float * num = new float []();
float den = 0;
for (int j=0; j<n; j++){
num += pow(W[j][i], m) * X[j];
den+=pow(W[j][i], m);
}
centers[i] = num / den;
}
//обновляем вероятности W и считаем расстояние между матрицами W и Wprev
float max_diff = 0;
for (int i=0; i<n; i++)
for (int j=0; j<c; j++){
total = 0;
for (int m=0; m<с; m++)
total += pow(distance(X[i], centers[j]) / distance(X[i], centers[m]), 2/(m-1));
W[i][j] = 1/total;
max_diff = max(abs(Wprev[i][j]-W[i][j]), max_diff);
Wprev[i][j] = W[i][j];
}
if (max_diff < eps):
break;
}
return W;
}

== Последовательная сложность алгоритма ==
Последовательная сложность алгоритма состоит из сложности каждой итерации умноженной на их количество. Так как число итераций заранее неизвестно и зависит от входных параметров, рассмотрим сложность на каждой итерации. Наибольшую сложность представляет собой пересчет матрицы, сложность которого <math>O(c^2 nd)</math> (по сравнению со сложностью <math>O(cnd)</math> расчета расстояний, вычисления центроидов и проверки условия останова). Итого общая сложность алгоритма <math>O(c^2 ndi)</math>

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

'''Первый ярус''' состоит из <math>M</math> параллельных операций 1, 2, совершаемых в цикле <math>c</math> раз для каждого кластера.

'''Операция 1''': <math>w_{ij}^m</math>, где <math>j</math> - номер итерации в цикле, <math>i</math> - номер параллельной ветви.

'''Операция 2''': <math>w_{ij}^m*X_i</math>

Здесь <math>j</math> - номер итерации в цикле, <math>i</math> - номер параллельной ветви.

На выходе из каждой ветки получаем вектор размера <math>1</math> x <math>c</math> и матрицу размера <math>d</math> x <math>c</math>.
Далее совершаем поэлементное сложение векторов и матриц соответственно, а затем делим каждый столбец в матрице на соответствующий элемент в векторе.

'''Второй ярус''' состоит их <math>M</math> параллельных операций 3, 4, 5 также совершаемых в цикле <math>c</math> раз.

'''Операция 3''': обновление значения <math>w_{ij}</math> по указанной в разделе 1.2 в пункте 5 формуле.

'''Операция 4''': <math>maximum = max(|w_{ij} - w_{ij}^{prev}|, maximum)</math>.

'''Операция 5''': <math>w_{ij}^{prev} = w_{ij}</math>.

Здесь <math>j</math> - номер итерации в цикле, <math>i</math> - номер параллельной ветви.

На выходе из каждой ветки получаем число <math>maximum</math>. Далее находим максимальное значение из полученных величин для каждой ветки. Затем проверяем условие останова алгоритма.

[[File:Scheme3.JPG]]

== Ресурс параллелизма алгоритма ==
Параллельная сложность алгоритма: <math>M*c^2*i</math>. Такая сложность получается за счет распараллеливания на каждом ярусе <math>M</math> операций. Иерархическая структура параллелизма подробно описана в [[#Информационный граф|п.1.7]].

В алгоритме не возникает скошенного параллелизма.

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

* Входные данные алгоритма: набор векторов <math>x_i</math> размерности <math>d</math>, где <math>i = 1,...,M</math>; <math>M</math> - количество векторов.
* Объем входных данных: <math>M*d</math> , [количество наблюдений * размерность].
* Выходные данные алгоритма: матрица вероятностей принадлежности векторов кластерам <math>M</math> на <math>c</math>.
* Объем выходных данных: <math>M*c</math> , [количество наблюдений * количество кластеров].

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

* Соотношение последовательной и параллельной формы алгоритма: <math>M</math>
* Вычислительная мощность: <math>{dc^2i} \over {c+d}</math>.
* Устойчивость: алгоритм не является устойчивым, поэтому существует много исследований о том, как первоначально выбрать параметры кластеризации.
* Сбалансированность: в данном алгоритме операция умножения доминирует над операцией сложения. Операции между параллельными ветвями сбалансированны.
* Детерминированность: алгоритм не является детерминированным, так как матрица нечеткого разбиение генерируется произвольно.
* Степень исхода вершины информационного графа ( для одной интерации): 2 (3 - с учетом, если выходные данные пошли на следующую итерацию).

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

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

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

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

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

Проведём исследование масштабируемости параллельной реализации нечеткого алгоритма С-средних.
Исследование проводилось на суперкомпьютере "Ломоносов"<ref name="Lom">Воеводин Вл., Жуматий С., Соболев С., Антонов А., Брызгалов П., Никитенко Д., Стефанов К., Воеводин Вад. Практика суперкомпьютера «Ломоносов» // Открытые системы, 2012, N 7, С. 36-39.</ref> [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета].
Была исследована собственная параллельная реализация алгоритма, написанная на языке C++ с использованием стандарта MPI. Сборка программы производилась при помощи компилятора компании Intel версии 13.1.0 с использованием библиотеки intelMPI версии 4.1.0 . Расчеты проводились в разделе test на узлах со следующими характеристиками: количество GPU - 0, количество ядер - 8 ядер архитектуры x86, количество памяти - 12 Гб.

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

* число процессоров [1 : 128];
* размер матрицы [10000 : 80000].

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

* минимальная эффективность реализации 0,33%;
* максимальная эффективность реализации 9,4%.

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

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

Построим оценки масштабируемости выбранной реализации нечеткого алгоритма С-средних:
* По числу процессов: 0.007. При увеличении числа процессов эффективность на рассмотренной области изменений параметров запуска увеличивается.
* По размеру задачи: -0.0016. При увеличении размера задачи эффективность уменьшается.
* По двум направлениям: 0,000077. При рассмотрении увеличения как вычислительной сложности, так и числа процессов на всей рассмотренной области значений эффективность увеличивается, однако скорость увеличения эффективности небольшая.

Была использована следующая реализация алгоритма.

#include <mpi.h>
#include <stdio.h>
#include <iostream>
#include <stdlib.h>
#include <math.h>
#include <string.h>
#include <time.h>
using namespace std;
double **x; //input matrix of size (n x x_dim)
int n;
int x_dim;
double **centroids; //cluster centroids matrix of size (n_cluster x x_dim)
int n_cluster; // number of clusters
double **w; //probability matrix of size (n x n_cluster)
double **dist; //distances matrix of size (n x n_cluster)
double eps; //max error
double m; //parameter of algo
int max_iter; // max num of iterations
double **num;
double *den;
double *allden;
double *err;
double *total_err;
int rank, size;
double ** generateZerosMatrix(int r, int c){
double ** arr = new double* [r];
for (int i = 0; i < r; ++i){
arr[i] = new double[c]();
}
return arr;
}
int generate_data()
{
//generate matrix
x = generateZerosMatrix(n, x_dim);
centroids = generateZerosMatrix(n_cluster, x_dim);
w = generateZerosMatrix(n, n_cluster);
dist = generateZerosMatrix(n, n_cluster);
num = generateZerosMatrix(n_cluster, x_dim);
//generate vectors
den = new double [n_cluster]();
allden = new double [n_cluster]();
//for stopping algorithm
err = new double;
total_err = new double;
srand(time(0));
//initialize w randomly with restrictions
for (int i = 0; i < n; ++i){
double sum = 0;
for (int j = 0; j < n_cluster; ++j){
w[i][j] = rand();
sum += w[i][j];
}
for (int j = 0; j < n_cluster; ++j){
w[i][j] /= sum;
}
}
//initialize x randomly
for (int i = 0; i < n; ++i)
for (int j = 0; j < x_dim; ++j)
x[i][j] = rand();
return 0;
}
double make_iteration() {
// calculate centroids centers
for (int i = rank; i < n; i+=size)
for (int j = 0; j < n_cluster; ++j){
double mu = pow(w[i][j], m);
den[j] += mu;
for (int k = 0; k < x_dim; ++k)
num[j][k] = mu * x[i][k];
}
MPI_Allreduce(den, allden, n_cluster, MPI_DOUBLE, MPI_SUM, MPI_COMM_WORLD);
for (int j=0; j < n_cluster; ++j)
MPI_Allreduce(num[j], centroids[j], x_dim, MPI_DOUBLE, MPI_SUM, MPI_COMM_WORLD);
for (int i = 0; i < n_cluster; ++i)
for (int j = 0; j < x_dim; ++j)
centroids[i][j] /= allden[i];
// calculate distances and probabilities, check stop conditions
double err = 0.0;
for (int i = rank; i < n; i+=size)
for (int j = 0; j < n_cluster; ++j){
for (int k = 0; k < x_dim; ++k)
dist[i][j] += (x[i][k] - centroids[j][k]) * (x[i][k] - centroids[j][k]);
double w_prev = w[i][j];
for (int k = 0; k < n_cluster; ++k)
w[i][j] += dist[i][j] / dist[i][k];
w[i][j] = 1.0 / pow(w[i][j], 1.0 / (m - 1));
err = fmax(err, abs(w_prev - w[i][j]));
}
return err;
}
int FCM(){
*total_err = eps+1;
int cur_iter = 0;
while (cur_iter < max_iter && *total_err > eps){
*err = make_iteration();
MPI_Allreduce(err, total_err, 1, MPI_DOUBLE, MPI_MAX, MPI_COMM_WORLD);
cur_iter++;
}
return cur_iter;
}
void clearMatrix(double ** matr, int r, int c){
for (int i = 0; i < r; ++i){
delete [] matr[i];
}
delete [] matr;
}
int memory_free(){
clearMatrix(x, n, x_dim);
clearMatrix(centroids, n_cluster, x_dim);
clearMatrix(w, n_cluster, n);
clearMatrix(num, n_cluster, x_dim);
clearMatrix(dist, n, n_cluster);
delete [] den;
delete [] allden;
delete err;
delete total_err;
return 0;
}
int main(int argc, char **argv){
MPI_Init(&argc, &argv);
MPI_Comm_size(MPI_COMM_WORLD, &size);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
int n_repeat = strtol(argv[1], NULL, 10);
int nx_min = strtol(argv[2], NULL, 10);
int nx_max = strtol(argv[3], NULL, 10);
int step = strtol(argv[4], NULL, 10);
x_dim = strtol(argv[5], NULL, 10);
m = strtod(argv[6], NULL);
n_cluster = strtol(argv[7], NULL, 10);
max_iter = strtol(argv[8], NULL, 10);
eps = strtod(argv[9], NULL);
//for all input matrix sizes
for (n = nx_min; n <= nx_max; n += step){
double start, finish, time_elapsed_iter=0;
int total_iterations = 0;
//repeat for getting mean value
for (int i = 0; i < n_repeat; ++i) {
generate_data();
MPI_Barrier(MPI_COMM_WORLD);
start = MPI_Wtime();
total_iterations += FCM();
finish = MPI_Wtime();
memory_free();
time_elapsed_iter += (finish-start);
}
time_elapsed_iter /= total_iterations;
if (rank == 0) {
cout << n << " " << size << " " << time_elapsed_iter << endl;
}
}
MPI_Finalize();
}

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

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

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

* Реализация алгоритма на POSTGRESQL: http://num-meth.srcc.msu.ru/zhurnal/tom_2012/pdf/v13r207.pdf
* Библиотека для MATLAB: http://www.mathworks.com/help/fuzzy/fcm.html (распространяется на коммерческой основе)

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

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

2016-12-18T19:31:23Z

Yushin:

{{Assignment|{{REVISIONUSER}}}}

{{algorithm
| name = Нечеткий алгоритм C средних
| serial_complexity = <math>O(Mdc^2i)</math>, <math>i</math> - количество итераций
| input_data = <math>M*d</math>, [количество наблюдений * размерность]
| output_data = <math>M*c</math>, [количество наблюдений * количество кластеров]
| pf_height = <math>2i</math>
| pf_width = <math>n</math>
}}

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

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

== Общее описание алгоритма ==
Кластеризация - это объединение объектов в группы (кластеры) на основе схожести признаков для объектов одной группы и отличий между группами. Нечеткий алгоритм C Средних (Fuzzy C-means, FCM) - алгоритм кластеризации, позволяющий объектам принадлежать с различной степенью нескольким кластерам одновременно. Впервые алгоритм был предложен J.C. Dunn в 1973 <ref>[http://www.tandfonline.com/doi/abs/10.1080/01969727308546046 | J. C. Dunn. A Fuzzy Relative of the ISODATA Process and Its Use in Detecting Compact Well-Separated Clusters. Journal of Cybernetics, volume 3,1973 - Issue 3, pp 32-57]</ref>. Нечеткое разбиение позволяет просто решить проблему объектов кластеризации, расположенных на границе двух кластеров - им назначают степени принадлежностей равные 0.5.

Входные данные алгоритма: набор векторов, которые следует кластеризовать.

Параметры алгоритма: <math>c</math> - количество кластеров;<math>m >= 1</math> - экспоненциальный вес, определяющий нечеткость кластеров; <math>\varepsilon</math> - параметр останова алгоритма.

Выходные данные: матрица вероятностей принадлежности векторов кластерам.

Краткое описание алгоритма:

* Задать параметры алгоритма.

* Сгенерировать случайную матрицу принадлежностей векторов кластерам (матрицу нечеткого разбиения).

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

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

Пусть <math> W = w_{ij} \in[0,1],\; i = 1, ..., M, \; j = 1, ..., c</math> - матрица разбиения, где <math>w_{i,j}</math> - степень принадлежности объекта <math>i</math> к кластеру <math>j</math>; <math>c</math> - количество кластеров, <math>M</math> - количество векторов, <math>X_i</math> - набор входных векторов размерности <math>d</math>.

При этом элементы матрицы должны удовлетворять условиям:

* <math>\sum_{j = 1}^c w_{ij} = 1, i = 1, ..., M</math>                <math>(1)</math>
* <math>0 < \sum_{i = 1}^M w_{ij} < M, j = 1, ..., c</math>       <math>(2)</math>

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

1) Задаем параметры алгоритма: <math>c</math> - количество кластеров; <math>m >= 1</math> - экспоненциальный вес, определяющий нечеткость кластеров; <math>\varepsilon > 0</math> - параметр останова алгоритма.

2) Генерируем случайным образом матрицу нечеткого разбиения с учетом условий <math>(1)</math> и <math>(2)</math>

3) Рассчитываем центроиды (центры кластеров): <math>V_j = {{\sum_{i=1}^M w_{ij}^m * X_i} \over {\sum_{i=1}^M w_{ij}^m}}, j = 1, ..., c</math>

4) Рассчитываем расстояния между объектами <math>X</math> и центроидами:

<math>D_{ij} = {||X_i - V_j||}, i = 1,...,M; j = 1,...,c </math>

5) Пересчет элементов матрицы разбиения:

при <math>D_{ij} >0</math> : <math>w_{ij} = {{1}\over {{ (\sum_{k=1}^c {{D_{ij}}\over{D_{ik}}} ) }^{2/(m-1)}}}, j = 1,...,c</math>

при <math>D_{ij} =0</math> : <math>w_{ij} = \delta_{ij}, j = 1,...,c</math>, где <math>\delta_{ij}</math> - символ Кронекера

6) Если <math>|| F - F^{*} || < \varepsilon </math>, где <math>F^{*}</math> - матрица нечеткого разбиения предыдущей итерации, то идем далее, иначе возвращаемся на пункт 3.

7) Конец.

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

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

* Поиск <math>V_j</math> - расчет центроидов (пункт 3 алгоритма)
* Нахождение <math>D_{ij}</math> - расстояний между объектами (пункт 4 алгоритма)
* Пересчет <math>w_{ij}</math> - элементов матрицы разбиения (пункт 5 алгоритма)

== Макроструктура алгоритма ==
Основные шаги при реализации алгоритма
* Генерация случайной матрицы размера <math>M</math> на где <math>c</math>, проверка условий
* Расчет центроидов – по сути, скалярное произведение с нормировкой
* Расчет расстояний – в общепринятом случае является скалярным произведением
* Пересчет матрицы – по сути, скалярное произведение
* Проверка условий останова – вычисление нормы

== Схема реализации последовательного алгоритма ==
float ** FuzzyCMeans (float** X, c, m, eps){
n = X.size();
r = X[0].size();
centers = generateZeroFill(c, r)
Wprev = genetateRandFill(n, c);
W = Wprev;
while (true){
// обновляем центры кластеров
for (int i=0; i<c; i++){
float * num = new float []();
float den = 0;
for (int j=0; j<n; j++){
num += pow(W[j][i], m) * X[j];
den+=pow(W[j][i], m);
}
centers[i] = num / den;
}
//обновляем вероятности W и считаем расстояние между матрицами W и Wprev
float max_diff = 0;
for (int i=0; i<n; i++)
for (int j=0; j<c; j++){
total = 0;
for (int m=0; m<с; m++)
total += pow(distance(X[i], centers[j]) / distance(X[i], centers[m]), 2/(m-1));
W[i][j] = 1/total;
max_diff = max(abs(Wprev[i][j]-W[i][j]), max_diff);
Wprev[i][j] = W[i][j];
}
if (max_diff < eps):
break;
}
return W;
}

== Последовательная сложность алгоритма ==
Последовательная сложность алгоритма состоит из сложности каждой итерации умноженной на их количество. Так как число итераций заранее неизвестно и зависит от входных параметров, рассмотрим сложность на каждой итерации. Наибольшую сложность представляет собой пересчет матрицы, сложность которого <math>O(c^2 nd)</math> (по сравнению со сложностью <math>O(cnd)</math> расчета расстояний, вычисления центроидов и проверки условия останова). Итого общая сложность алгоритма <math>O(c^2 ndi)</math>

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

'''Первый ярус''' состоит из <math>M</math> параллельных операций 1, 2, совершаемых в цикле <math>c</math> раз для каждого кластера.

'''Операция 1''': <math>w_{ij}^m</math>, где <math>j</math> - номер итерации в цикле, <math>i</math> - номер параллельной ветви.

'''Операция 2''': <math>w_{ij}^m*X_i</math>

Здесь <math>j</math> - номер итерации в цикле, <math>i</math> - номер параллельной ветви.

На выходе из каждой ветки получаем вектор размера <math>1</math> x <math>c</math> и матрицу размера <math>d</math> x <math>c</math>.
Далее совершаем поэлементное сложение векторов и матриц соответственно, а затем делим каждый столбец в матрице на соответствующий элемент в векторе.

'''Второй ярус''' состоит их <math>M</math> параллельных операций 3, 4, 5 также совершаемых в цикле <math>c</math> раз.

'''Операция 3''': обновление значения <math>w_{ij}</math> по указанной в разделе 1.2 в пункте 5 формуле.

'''Операция 4''': <math>maximum = max(|w_{ij} - w_{ij}^{prev}|, maximum)</math>.

'''Операция 5''': <math>w_{ij}^{prev} = w_{ij}</math>.

Здесь <math>j</math> - номер итерации в цикле, <math>i</math> - номер параллельной ветви.

На выходе из каждой ветки получаем число <math>maximum</math>. Далее находим максимальное значение из полученных величин для каждой ветки. Затем проверяем условие останова алгоритма.

[[File:Scheme3.JPG]]

== Ресурс параллелизма алгоритма ==
Параллельная сложность алгоритма: <math>M*c^2*i</math>. Такая сложность получается за счет распараллеливания на каждом ярусе <math>M</math> операций. Иерархическая структура параллелизма подробно описана в [[#Информационный граф|п.1.7]].

В алгоритме не возникает скошенного параллелизма.

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

* Входные данные алгоритма: набор векторов <math>x_i</math> размерности <math>d</math>, где <math>i = 1,...,M</math>; <math>M</math> - количество векторов.
* Объем входных данных: <math>M*d</math> , [количество наблюдений * размерность].
* Выходные данные алгоритма: матрица вероятностей принадлежности векторов кластерам <math>M</math> на <math>c</math>.
* Объем выходных данных: <math>M*c</math> , [количество наблюдений * количество кластеров].

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

* Соотношение последовательной и параллельной формы алгоритма: <math>M</math>
* Вычислительная мощность: <math>{dc^2i} \over {c+d}</math>.
* Устойчивость: алгоритм не является устойчивым, поэтому существует много исследований о том, как первоначально выбрать параметры кластеризации.
* Сбалансированность: в данном алгоритме операция умножения доминирует над операцией сложения. Операции между параллельными ветвями сбалансированны.
* Детерминированность: алгоритм не является детерминированным, так как матрица нечеткого разбиение генерируется произвольно.
* Степень исхода вершины информационного графа ( для одной интерации): 2 (3 - с учетом, если выходные данные пошли на следующую итерацию).

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

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

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

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

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

Проведём исследование масштабируемости параллельной реализации нечеткого алгоритма С-средних.
Исследование проводилось на суперкомпьютере "Ломоносов"<ref name="Lom">Воеводин Вл., Жуматий С., Соболев С., Антонов А., Брызгалов П., Никитенко Д., Стефанов К., Воеводин Вад. Практика суперкомпьютера «Ломоносов» // Открытые системы, 2012, N 7, С. 36-39.</ref> [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета].
Была исследована собственная параллельная реализация алгоритма, написанная на языке C++ с использованием стандарта MPI. Сборка программы производилась при помощи компилятора компании Intel версии 13.1.0 с использованием библиотеки intelMPI версии 4.1.0 . Расчеты проводились в разделе test на узлах со следующими характеристиками: количество GPU - 0, количество ядер - 8 ядер архитектуры x86, количество памяти - 12 Гб.

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

* число процессоров [1 : 128];
* размер матрицы [10000 : 80000].

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

* минимальная эффективность реализации 0,33%;
* максимальная эффективность реализации 9,4%.

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

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

Построим оценки масштабируемости выбранной реализации нечеткого алгоритма С-средних:
* По числу процессов: 0.007. При увеличении числа процессов эффективность на рассмотренной области изменений параметров запуска увеличивается.
* По размеру задачи: -0.0016. При увеличении размера задачи эффективность уменьшается.
* По двум направлениям: 0,000077. При рассмотрении увеличения как вычислительной сложности, так и числа процессов на всей рассмотренной области значений эффективность увеличивается, однако скорость увеличения эффективности небольшая.

Была использована следующая реализация алгоритма.

#include <mpi.h>
#include <stdio.h>
#include <iostream>
#include <stdlib.h>
#include <math.h>
#include <string.h>
#include <time.h>
using namespace std;
double **x; //input matrix of size (n x x_dim)
int n;
int x_dim;
double **centroids; //cluster centroids matrix of size (n_cluster x x_dim)
int n_cluster; // number of clusters
double **w; //probability matrix of size (n x n_cluster)
double **dist; //distances matrix of size (n x n_cluster)
double eps; //max error
double m; //parameter of algo
int max_iter; // max num of iterations
double **num;
double *den;
double *allden;
double *err;
double *total_err;
int rank, size;
double ** generateZerosMatrix(int r, int c){
double ** arr = new double* [r];
for (int i = 0; i < r; ++i){
arr[i] = new double[c]();
}
return arr;
}
int generate_data()
{
//generate matrix
x = generateZerosMatrix(n, x_dim);
centroids = generateZerosMatrix(n_cluster, x_dim);
w = generateZerosMatrix(n, n_cluster);
dist = generateZerosMatrix(n, n_cluster);
num = generateZerosMatrix(n_cluster, x_dim);
//generate vectors
den = new double [n_cluster]();
allden = new double [n_cluster]();
//for stopping algorithm
err = new double;
total_err = new double;
srand(time(0));
//initialize w randomly with restrictions
for (int i = 0; i < n; ++i){
double sum = 0;
for (int j = 0; j < n_cluster; ++j){
w[i][j] = rand();
sum += w[i][j];
}
for (int j = 0; j < n_cluster; ++j){
w[i][j] /= sum;
}
}
//initialize x randomly
for (int i = 0; i < n; ++i)
for (int j = 0; j < x_dim; ++j)
x[i][j] = rand();
return 0;
}
double make_iteration() {
// calculate centroids centers
for (int i = rank; i < n; i+=size)
for (int j = 0; j < n_cluster; ++j){
double mu = pow(w[i][j], m);
den[j] += mu;
for (int k = 0; k < x_dim; ++k)
num[j][k] = mu * x[i][k];
}
MPI_Allreduce(den, allden, n_cluster, MPI_DOUBLE, MPI_SUM, MPI_COMM_WORLD);
for (int j=0; j < n_cluster; ++j)
MPI_Allreduce(num[j], centroids[j], x_dim, MPI_DOUBLE, MPI_SUM, MPI_COMM_WORLD);
for (int i = 0; i < n_cluster; ++i)
for (int j = 0; j < x_dim; ++j)
centroids[i][j] /= allden[i];
// calculate distances and probabilities, check stop conditions
double err = 0.0;
for (int i = rank; i < n; i+=size)
for (int j = 0; j < n_cluster; ++j){
for (int k = 0; k < x_dim; ++k)
dist[i][j] += (x[i][k] - centroids[j][k]) * (x[i][k] - centroids[j][k]);
double w_prev = w[i][j];
for (int k = 0; k < n_cluster; ++k)
w[i][j] += dist[i][j] / dist[i][k];
w[i][j] = 1.0 / pow(w[i][j], 1.0 / (m - 1));
err = fmax(err, abs(w_prev - w[i][j]));
}
return err;
}
int FCM(){
*total_err = eps+1;
int cur_iter = 0;
while (cur_iter < max_iter && *total_err > eps){
*err = make_iteration();
MPI_Allreduce(err, total_err, 1, MPI_DOUBLE, MPI_MAX, MPI_COMM_WORLD);
cur_iter++;
}
return cur_iter;
}
void clearMatrix(double ** matr, int r, int c){
for (int i = 0; i < r; ++i){
delete [] matr[i];
}
delete [] matr;
}
int memory_free(){
clearMatrix(x, n, x_dim);
clearMatrix(centroids, n_cluster, x_dim);
clearMatrix(w, n_cluster, n);
clearMatrix(num, n_cluster, x_dim);
clearMatrix(dist, n, n_cluster);
delete [] den;
delete [] allden;
delete err;
delete total_err;
return 0;
}
int main(int argc, char **argv){
MPI_Init(&argc, &argv);
MPI_Comm_size(MPI_COMM_WORLD, &size);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
int n_repeat = strtol(argv[1], NULL, 10);
int nx_min = strtol(argv[2], NULL, 10);
int nx_max = strtol(argv[3], NULL, 10);
int step = strtol(argv[4], NULL, 10);
x_dim = strtol(argv[5], NULL, 10);
m = strtod(argv[6], NULL);
n_cluster = strtol(argv[7], NULL, 10);
max_iter = strtol(argv[8], NULL, 10);
eps = strtod(argv[9], NULL);
//for all input matrix sizes
for (n = nx_min; n <= nx_max; n += step){
double start, finish, time_elapsed_iter=0;
int total_iterations = 0;
//repeat for getting mean value
for (int i = 0; i < n_repeat; ++i) {
generate_data();
MPI_Barrier(MPI_COMM_WORLD);
start = MPI_Wtime();
total_iterations += FCM();
finish = MPI_Wtime();
memory_free();
time_elapsed_iter += (finish-start);
}
time_elapsed_iter /= total_iterations;
if (rank == 0) {
cout << n << " " << size << " " << time_elapsed_iter << endl;
}
}
MPI_Finalize();
}

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

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

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

* Реализация алгоритма на POSTGRESQL: http://num-meth.srcc.msu.ru/zhurnal/tom_2012/pdf/v13r207.pdf
* Библиотека для MATLAB: http://www.mathworks.com/help/fuzzy/fcm.html (распространяется на коммерческой основе)

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

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

2016-12-18T19:30:30Z

Yushin:

{{Assignment|{{REVISIONUSER}}}}

{{algorithm
| name = Нечеткий алгоритм C средних
| serial_complexity = <math>O(Mdc^2i)</math>, <math>i</math> - количество итераций
| input_data = <math>M*d</math>, [количество наблюдений * размерность]
| output_data = <math>M*c</math>, [количество наблюдений * количество кластеров]
| pf_height = <math>2i</math>
| pf_width = <math>n</math>
}}

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

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

== Общее описание алгоритма ==
Кластеризация - это объединение объектов в группы (кластеры) на основе схожести признаков для объектов одной группы и отличий между группами. Нечеткий алгоритм C Средних (Fuzzy C-means, FCM) - алгоритм кластеризации, позволяющий объектам принадлежать с различной степенью нескольким кластерам одновременно. Впервые алгоритм был предложен J.C. Dunn в 1973 <ref>[http://www.tandfonline.com/doi/abs/10.1080/01969727308546046 | J. C. Dunn. A Fuzzy Relative of the ISODATA Process and Its Use in Detecting Compact Well-Separated Clusters. Journal of Cybernetics, volume 3,1973 - Issue 3, pp 32-57]</ref>. Нечеткое разбиение позволяет просто решить проблему объектов кластеризации, расположенных на границе двух кластеров - им назначают степени принадлежностей равные 0.5.

Входные данные алгоритма: набор векторов, которые следует кластеризовать.

Параметры алгоритма: <math>c</math> - количество кластеров;<math>m >= 1</math> - экспоненциальный вес, определяющий нечеткость кластеров; <math>\varepsilon</math> - параметр останова алгоритма.

Выходные данные: матрица вероятностей принадлежности векторов кластерам.

Краткое описание алгоритма:

* Задать параметры алгоритма.

* Сгенерировать случайную матрицу принадлежностей векторов кластерам (матрицу нечеткого разбиения).

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

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

Пусть <math> W = w_{ij} \in[0,1],\; i = 1, ..., M, \; j = 1, ..., c</math> - матрица разбиения, где <math>w_{i,j}</math> - степень принадлежности объекта <math>i</math> к кластеру <math>j</math>; <math>c</math> - количество кластеров, <math>M</math> - количество векторов, <math>X_i</math> - набор входных векторов размерности <math>d</math>, <math>i = 1,...,M</math>.

При этом элементы матрицы должны удовлетворять условиям:

* <math>\sum_{j = 1}^c w_{ij} = 1, i = 1, ..., M</math>                <math>(1)</math>
* <math>0 < \sum_{i = 1}^M w_{ij} < M, j = 1, ..., c</math>       <math>(2)</math>

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

1) Задаем параметры алгоритма: <math>c</math> - количество кластеров; <math>m >= 1</math> - экспоненциальный вес, определяющий нечеткость кластеров; <math>\varepsilon > 0</math> - параметр останова алгоритма.

2) Генерируем случайным образом матрицу нечеткого разбиения с учетом условий <math>(1)</math> и <math>(2)</math>

3) Рассчитываем центроиды (центры кластеров): <math>V_j = {{\sum_{i=1}^M w_{ij}^m * X_i} \over {\sum_{i=1}^M w_{ij}^m}}, j = 1, ..., c</math>

4) Рассчитываем расстояния между объектами <math>X</math> и центроидами:

<math>D_{ij} = {||X_i - V_j||}, i = 1,...,M; j = 1,...,c </math>

5) Пересчет элементов матрицы разбиения:

при <math>D_{ij} >0</math> : <math>w_{ij} = {{1}\over {{ (\sum_{k=1}^c {{D_{ij}}\over{D_{ik}}} ) }^{2/(m-1)}}}, j = 1,...,c</math>

при <math>D_{ij} =0</math> : <math>w_{ij} = \delta_{ij}, j = 1,...,c</math>, где <math>\delta_{ij}</math> - символ Кронекера

6) Если <math>|| F - F^{*} || < \varepsilon </math>, где <math>F^{*}</math> - матрица нечеткого разбиения предыдущей итерации, то идем далее, иначе возвращаемся на пункт 3.

7) Конец.

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

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

* Поиск <math>V_j</math> - расчет центроидов (пункт 3 алгоритма)
* Нахождение <math>D_{ij}</math> - расстояний между объектами (пункт 4 алгоритма)
* Пересчет <math>w_{ij}</math> - элементов матрицы разбиения (пункт 5 алгоритма)

== Макроструктура алгоритма ==
Основные шаги при реализации алгоритма
* Генерация случайной матрицы размера <math>M</math> на где <math>c</math>, проверка условий
* Расчет центроидов – по сути, скалярное произведение с нормировкой
* Расчет расстояний – в общепринятом случае является скалярным произведением
* Пересчет матрицы – по сути, скалярное произведение
* Проверка условий останова – вычисление нормы

== Схема реализации последовательного алгоритма ==
float ** FuzzyCMeans (float** X, c, m, eps){
n = X.size();
r = X[0].size();
centers = generateZeroFill(c, r)
Wprev = genetateRandFill(n, c);
W = Wprev;
while (true){
// обновляем центры кластеров
for (int i=0; i<c; i++){
float * num = new float []();
float den = 0;
for (int j=0; j<n; j++){
num += pow(W[j][i], m) * X[j];
den+=pow(W[j][i], m);
}
centers[i] = num / den;
}
//обновляем вероятности W и считаем расстояние между матрицами W и Wprev
float max_diff = 0;
for (int i=0; i<n; i++)
for (int j=0; j<c; j++){
total = 0;
for (int m=0; m<с; m++)
total += pow(distance(X[i], centers[j]) / distance(X[i], centers[m]), 2/(m-1));
W[i][j] = 1/total;
max_diff = max(abs(Wprev[i][j]-W[i][j]), max_diff);
Wprev[i][j] = W[i][j];
}
if (max_diff < eps):
break;
}
return W;
}

== Последовательная сложность алгоритма ==
Последовательная сложность алгоритма состоит из сложности каждой итерации умноженной на их количество. Так как число итераций заранее неизвестно и зависит от входных параметров, рассмотрим сложность на каждой итерации. Наибольшую сложность представляет собой пересчет матрицы, сложность которого <math>O(c^2 nd)</math> (по сравнению со сложностью <math>O(cnd)</math> расчета расстояний, вычисления центроидов и проверки условия останова). Итого общая сложность алгоритма <math>O(c^2 ndi)</math>

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

'''Первый ярус''' состоит из <math>M</math> параллельных операций 1, 2, совершаемых в цикле <math>c</math> раз для каждого кластера.

'''Операция 1''': <math>w_{ij}^m</math>, где <math>j</math> - номер итерации в цикле, <math>i</math> - номер параллельной ветви.

'''Операция 2''': <math>w_{ij}^m*X_i</math>

Здесь <math>j</math> - номер итерации в цикле, <math>i</math> - номер параллельной ветви.

На выходе из каждой ветки получаем вектор размера <math>1</math> x <math>c</math> и матрицу размера <math>d</math> x <math>c</math>.
Далее совершаем поэлементное сложение векторов и матриц соответственно, а затем делим каждый столбец в матрице на соответствующий элемент в векторе.

'''Второй ярус''' состоит их <math>M</math> параллельных операций 3, 4, 5 также совершаемых в цикле <math>c</math> раз.

'''Операция 3''': обновление значения <math>w_{ij}</math> по указанной в разделе 1.2 в пункте 5 формуле.

'''Операция 4''': <math>maximum = max(|w_{ij} - w_{ij}^{prev}|, maximum)</math>.

'''Операция 5''': <math>w_{ij}^{prev} = w_{ij}</math>.

Здесь <math>j</math> - номер итерации в цикле, <math>i</math> - номер параллельной ветви.

На выходе из каждой ветки получаем число <math>maximum</math>. Далее находим максимальное значение из полученных величин для каждой ветки. Затем проверяем условие останова алгоритма.

[[File:Scheme3.JPG]]

== Ресурс параллелизма алгоритма ==
Параллельная сложность алгоритма: <math>M*c^2*i</math>. Такая сложность получается за счет распараллеливания на каждом ярусе <math>M</math> операций. Иерархическая структура параллелизма подробно описана в [[#Информационный граф|п.1.7]].

В алгоритме не возникает скошенного параллелизма.

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

* Входные данные алгоритма: набор векторов <math>x_i</math> размерности <math>d</math>, где <math>i = 1,...,M</math>; <math>M</math> - количество векторов.
* Объем входных данных: <math>M*d</math> , [количество наблюдений * размерность].
* Выходные данные алгоритма: матрица вероятностей принадлежности векторов кластерам <math>M</math> на <math>c</math>.
* Объем выходных данных: <math>M*c</math> , [количество наблюдений * количество кластеров].

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

* Соотношение последовательной и параллельной формы алгоритма: <math>M</math>
* Вычислительная мощность: <math>{dc^2i} \over {c+d}</math>.
* Устойчивость: алгоритм не является устойчивым, поэтому существует много исследований о том, как первоначально выбрать параметры кластеризации.
* Сбалансированность: в данном алгоритме операция умножения доминирует над операцией сложения. Операции между параллельными ветвями сбалансированны.
* Детерминированность: алгоритм не является детерминированным, так как матрица нечеткого разбиение генерируется произвольно.
* Степень исхода вершины информационного графа ( для одной интерации): 2 (3 - с учетом, если выходные данные пошли на следующую итерацию).

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

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

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

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

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

Проведём исследование масштабируемости параллельной реализации нечеткого алгоритма С-средних.
Исследование проводилось на суперкомпьютере "Ломоносов"<ref name="Lom">Воеводин Вл., Жуматий С., Соболев С., Антонов А., Брызгалов П., Никитенко Д., Стефанов К., Воеводин Вад. Практика суперкомпьютера «Ломоносов» // Открытые системы, 2012, N 7, С. 36-39.</ref> [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета].
Была исследована собственная параллельная реализация алгоритма, написанная на языке C++ с использованием стандарта MPI. Сборка программы производилась при помощи компилятора компании Intel версии 13.1.0 с использованием библиотеки intelMPI версии 4.1.0 . Расчеты проводились в разделе test на узлах со следующими характеристиками: количество GPU - 0, количество ядер - 8 ядер архитектуры x86, количество памяти - 12 Гб.

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

* число процессоров [1 : 128];
* размер матрицы [10000 : 80000].

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

* минимальная эффективность реализации 0,33%;
* максимальная эффективность реализации 9,4%.

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

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

Построим оценки масштабируемости выбранной реализации нечеткого алгоритма С-средних:
* По числу процессов: 0.007. При увеличении числа процессов эффективность на рассмотренной области изменений параметров запуска увеличивается.
* По размеру задачи: -0.0016. При увеличении размера задачи эффективность уменьшается.
* По двум направлениям: 0,000077. При рассмотрении увеличения как вычислительной сложности, так и числа процессов на всей рассмотренной области значений эффективность увеличивается, однако скорость увеличения эффективности небольшая.

Была использована следующая реализация алгоритма.

#include <mpi.h>
#include <stdio.h>
#include <iostream>
#include <stdlib.h>
#include <math.h>
#include <string.h>
#include <time.h>
using namespace std;
double **x; //input matrix of size (n x x_dim)
int n;
int x_dim;
double **centroids; //cluster centroids matrix of size (n_cluster x x_dim)
int n_cluster; // number of clusters
double **w; //probability matrix of size (n x n_cluster)
double **dist; //distances matrix of size (n x n_cluster)
double eps; //max error
double m; //parameter of algo
int max_iter; // max num of iterations
double **num;
double *den;
double *allden;
double *err;
double *total_err;
int rank, size;
double ** generateZerosMatrix(int r, int c){
double ** arr = new double* [r];
for (int i = 0; i < r; ++i){
arr[i] = new double[c]();
}
return arr;
}
int generate_data()
{
//generate matrix
x = generateZerosMatrix(n, x_dim);
centroids = generateZerosMatrix(n_cluster, x_dim);
w = generateZerosMatrix(n, n_cluster);
dist = generateZerosMatrix(n, n_cluster);
num = generateZerosMatrix(n_cluster, x_dim);
//generate vectors
den = new double [n_cluster]();
allden = new double [n_cluster]();
//for stopping algorithm
err = new double;
total_err = new double;
srand(time(0));
//initialize w randomly with restrictions
for (int i = 0; i < n; ++i){
double sum = 0;
for (int j = 0; j < n_cluster; ++j){
w[i][j] = rand();
sum += w[i][j];
}
for (int j = 0; j < n_cluster; ++j){
w[i][j] /= sum;
}
}
//initialize x randomly
for (int i = 0; i < n; ++i)
for (int j = 0; j < x_dim; ++j)
x[i][j] = rand();
return 0;
}
double make_iteration() {
// calculate centroids centers
for (int i = rank; i < n; i+=size)
for (int j = 0; j < n_cluster; ++j){
double mu = pow(w[i][j], m);
den[j] += mu;
for (int k = 0; k < x_dim; ++k)
num[j][k] = mu * x[i][k];
}
MPI_Allreduce(den, allden, n_cluster, MPI_DOUBLE, MPI_SUM, MPI_COMM_WORLD);
for (int j=0; j < n_cluster; ++j)
MPI_Allreduce(num[j], centroids[j], x_dim, MPI_DOUBLE, MPI_SUM, MPI_COMM_WORLD);
for (int i = 0; i < n_cluster; ++i)
for (int j = 0; j < x_dim; ++j)
centroids[i][j] /= allden[i];
// calculate distances and probabilities, check stop conditions
double err = 0.0;
for (int i = rank; i < n; i+=size)
for (int j = 0; j < n_cluster; ++j){
for (int k = 0; k < x_dim; ++k)
dist[i][j] += (x[i][k] - centroids[j][k]) * (x[i][k] - centroids[j][k]);
double w_prev = w[i][j];
for (int k = 0; k < n_cluster; ++k)
w[i][j] += dist[i][j] / dist[i][k];
w[i][j] = 1.0 / pow(w[i][j], 1.0 / (m - 1));
err = fmax(err, abs(w_prev - w[i][j]));
}
return err;
}
int FCM(){
*total_err = eps+1;
int cur_iter = 0;
while (cur_iter < max_iter && *total_err > eps){
*err = make_iteration();
MPI_Allreduce(err, total_err, 1, MPI_DOUBLE, MPI_MAX, MPI_COMM_WORLD);
cur_iter++;
}
return cur_iter;
}
void clearMatrix(double ** matr, int r, int c){
for (int i = 0; i < r; ++i){
delete [] matr[i];
}
delete [] matr;
}
int memory_free(){
clearMatrix(x, n, x_dim);
clearMatrix(centroids, n_cluster, x_dim);
clearMatrix(w, n_cluster, n);
clearMatrix(num, n_cluster, x_dim);
clearMatrix(dist, n, n_cluster);
delete [] den;
delete [] allden;
delete err;
delete total_err;
return 0;
}
int main(int argc, char **argv){
MPI_Init(&argc, &argv);
MPI_Comm_size(MPI_COMM_WORLD, &size);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
int n_repeat = strtol(argv[1], NULL, 10);
int nx_min = strtol(argv[2], NULL, 10);
int nx_max = strtol(argv[3], NULL, 10);
int step = strtol(argv[4], NULL, 10);
x_dim = strtol(argv[5], NULL, 10);
m = strtod(argv[6], NULL);
n_cluster = strtol(argv[7], NULL, 10);
max_iter = strtol(argv[8], NULL, 10);
eps = strtod(argv[9], NULL);
//for all input matrix sizes
for (n = nx_min; n <= nx_max; n += step){
double start, finish, time_elapsed_iter=0;
int total_iterations = 0;
//repeat for getting mean value
for (int i = 0; i < n_repeat; ++i) {
generate_data();
MPI_Barrier(MPI_COMM_WORLD);
start = MPI_Wtime();
total_iterations += FCM();
finish = MPI_Wtime();
memory_free();
time_elapsed_iter += (finish-start);
}
time_elapsed_iter /= total_iterations;
if (rank == 0) {
cout << n << " " << size << " " << time_elapsed_iter << endl;
}
}
MPI_Finalize();
}

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

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

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

* Реализация алгоритма на POSTGRESQL: http://num-meth.srcc.msu.ru/zhurnal/tom_2012/pdf/v13r207.pdf
* Библиотека для MATLAB: http://www.mathworks.com/help/fuzzy/fcm.html (распространяется на коммерческой основе)

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

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

2016-12-18T19:22:01Z

Yushin:

{{Assignment|{{REVISIONUSER}}}}

{{algorithm
| name = Нечеткий алгоритм C средних
| serial_complexity = <math>O(Mdc^2i)</math>, <math>i</math> - количество итераций
| input_data = <math>M*d</math>, [количество наблюдений * размерность]
| output_data = <math>M*c</math>, [количество наблюдений * количество кластеров]
| pf_height = <math>2i</math>
| pf_width = <math>n</math>
}}

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

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

== Общее описание алгоритма ==
Кластеризация - это объединение объектов в группы (кластеры) на основе схожести признаков для объектов одной группы и отличий между группами. Нечеткий алгоритм C Средних (Fuzzy C-means, FCM) - алгоритм кластеризации, позволяющий объектам принадлежать с различной степенью нескольким кластерам одновременно. Впервые алгоритм был предложен J.C. Dunn в 1973 <ref>[http://www.tandfonline.com/doi/abs/10.1080/01969727308546046 | J. C. Dunn. A Fuzzy Relative of the ISODATA Process and Its Use in Detecting Compact Well-Separated Clusters. Journal of Cybernetics, volume 3,1973 - Issue 3, pp 32-57]</ref>. Нечеткое разбиение позволяет просто решить проблему объектов кластеризации, расположенных на границе двух кластеров - им назначают степени принадлежностей равные 0.5.

Входные данные алгоритма: набор векторов, которые следует кластеризовать.

Параметры алгоритма: <math>c</math> - количество кластеров;<math>m >= 1</math> - экспоненциальный вес, определяющий нечеткость кластеров; <math>\varepsilon</math> - параметр останова алгоритма.

Выходные данные: матрица вероятностей принадлежности векторов кластерам.

Краткое описание алгоритма:

* Задать параметры алгоритма.

* Сгенерировать случайную матрицу принадлежностей векторов кластерам (матрицу нечеткого разбиения).

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

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

Пусть <math> W = w_{ij} \in[0,1],\; i = 1, ..., M, \; j = 1, ..., c</math> - матрица разбиения, где <math>w_{i,j}</math> - степень принадлежности объекта <math>i</math> к кластеру <math>j</math>; <math>c</math> - количество кластеров, <math>M</math> - количество векторов.

При этом элементы матрицы должны удовлетворять условиям:

* <math>\sum_{j = 1}^c w_{ij} = 1, i = 1, ..., M</math>                <math>(1)</math>
* <math>0 < \sum_{i = 1}^M w_{ij} < M, j = 1, ..., c</math>       <math>(2)</math>

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

1) Задаем параметры алгоритма: <math>c</math> - количество кластеров; <math>m >= 1</math> - экспоненциальный вес, определяющий нечеткость кластеров; <math>\varepsilon > 0</math> - параметр останова алгоритма.

2) Генерируем случайным образом матрицу нечеткого разбиения с учетом условий <math>(1)</math> и <math>(2)</math>

3) Рассчитываем центроиды (центры кластеров): <math>V_j = {{\sum_{i=1}^M w_{ij}^m * X_i} \over {\sum_{i=1}^M w_{ij}^m}}, j = 1, ..., c</math>

4) Рассчитываем расстояния между объектами <math>X</math> и центроидами:

<math>D_{ij} = {||X_i - V_j||}, i = 1,...,M; j = 1,...,c </math>

5) Пересчет элементов матрицы разбиения:

при <math>D_{ij} >0</math> : <math>w_{ij} = {{1}\over {{ (\sum_{k=1}^c {{D_{ij}}\over{D_{ik}}} ) }^{2/(m-1)}}}, j = 1,...,c</math>

при <math>D_{ij} =0</math> : <math>w_{ij} = \delta_{ij}, j = 1,...,c</math>, где <math>\delta_{ij}</math> - символ Кронекера

6) Если <math>|| F - F^{*} || < \varepsilon </math>, где <math>F^{*}</math> - матрица нечеткого разбиения предыдущей итерации, то идем далее, иначе возвращаемся на пункт 3.

7) Конец.

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

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

* Поиск <math>V_j</math> - расчет центроидов (пункт 3 алгоритма)
* Нахождение <math>D_{ij}</math> - расстояний между объектами (пункт 4 алгоритма)
* Пересчет <math>w_{ij}</math> - элементов матрицы разбиения (пункт 5 алгоритма)

== Макроструктура алгоритма ==
Основные шаги при реализации алгоритма
* Генерация случайной матрицы размера <math>M</math> на где <math>c</math>, проверка условий
* Расчет центроидов – по сути, скалярное произведение с нормировкой
* Расчет расстояний – в общепринятом случае является скалярным произведением
* Пересчет матрицы – по сути, скалярное произведение
* Проверка условий останова – вычисление нормы

== Схема реализации последовательного алгоритма ==
float ** FuzzyCMeans (float** X, c, m, eps){
n = X.size();
r = X[0].size();
centers = generateZeroFill(c, r)
Wprev = genetateRandFill(n, c);
W = Wprev;
while (true){
// обновляем центры кластеров
for (int i=0; i<c; i++){
float * num = new float []();
float den = 0;
for (int j=0; j<n; j++){
num += pow(W[j][i], m) * X[j];
den+=pow(W[j][i], m);
}
centers[i] = num / den;
}
//обновляем вероятности W и считаем расстояние между матрицами W и Wprev
float max_diff = 0;
for (int i=0; i<n; i++)
for (int j=0; j<c; j++){
total = 0;
for (int m=0; m<с; m++)
total += pow(distance(X[i], centers[j]) / distance(X[i], centers[m]), 2/(m-1));
W[i][j] = 1/total;
max_diff = max(abs(Wprev[i][j]-W[i][j]), max_diff);
Wprev[i][j] = W[i][j];
}
if (max_diff < eps):
break;
}
return W;
}

== Последовательная сложность алгоритма ==
Последовательная сложность алгоритма состоит из сложности каждой итерации умноженной на их количество. Так как число итераций заранее неизвестно и зависит от входных параметров, рассмотрим сложность на каждой итерации. Наибольшую сложность представляет собой пересчет матрицы, сложность которого <math>O(c^2 nd)</math> (по сравнению со сложностью <math>O(cnd)</math> расчета расстояний, вычисления центроидов и проверки условия останова). Итого общая сложность алгоритма <math>O(c^2 ndi)</math>

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

'''Первый ярус''' состоит из <math>M</math> параллельных операций 1, 2, совершаемых в цикле <math>c</math> раз для каждого кластера.

'''Операция 1''': <math>w_{ij}^m</math>, где <math>j</math> - номер итерации в цикле, <math>i</math> - номер параллельной ветви.

'''Операция 2''': <math>w_{ij}^m*X_i</math>

Здесь <math>j</math> - номер итерации в цикле, <math>i</math> - номер параллельной ветви.

На выходе из каждой ветки получаем вектор размера <math>1</math> x <math>c</math> и матрицу размера <math>d</math> x <math>c</math>.
Далее совершаем поэлементное сложение векторов и матриц соответственно, а затем делим каждый столбец в матрице на соответствующий элемент в векторе.

'''Второй ярус''' состоит их <math>M</math> параллельных операций 3, 4, 5 также совершаемых в цикле <math>c</math> раз.

'''Операция 3''': обновление значения <math>w_{ij}</math> по указанной в разделе 1.2 в пункте 5 формуле.

'''Операция 4''': <math>maximum = max(|w_{ij} - w_{ij}^{prev}|, maximum)</math>.

'''Операция 5''': <math>w_{ij}^{prev} = w_{ij}</math>.

Здесь <math>j</math> - номер итерации в цикле, <math>i</math> - номер параллельной ветви.

На выходе из каждой ветки получаем число <math>maximum</math>. Далее находим максимальное значение из полученных величин для каждой ветки. Затем проверяем условие останова алгоритма.

[[File:Scheme3.JPG]]

== Ресурс параллелизма алгоритма ==
Параллельная сложность алгоритма: <math>M*c^2*i</math>. Такая сложность получается за счет распараллеливания на каждом ярусе <math>M</math> операций. Иерархическая структура параллелизма подробно описана в [[#Информационный граф|п.1.7]].

В алгоритме не возникает скошенного параллелизма.

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

* Входные данные алгоритма: набор векторов <math>x_i</math> размерности <math>d</math>, где <math>i = 1,...,M</math>; <math>M</math> - количество векторов.
* Объем входных данных: <math>M*d</math> , [количество наблюдений * размерность].
* Выходные данные алгоритма: матрица вероятностей принадлежности векторов кластерам <math>M</math> на <math>c</math>.
* Объем выходных данных: <math>M*c</math> , [количество наблюдений * количество кластеров].

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

* Соотношение последовательной и параллельной формы алгоритма: <math>M</math>
* Вычислительная мощность: <math>{dc^2i} \over {c+d}</math>.
* Устойчивость: алгоритм не является устойчивым, поэтому существует много исследований о том, как первоначально выбрать параметры кластеризации.
* Сбалансированность: в данном алгоритме операция умножения доминирует над операцией сложения. Операции между параллельными ветвями сбалансированны.
* Детерминированность: алгоритм не является детерминированным, так как матрица нечеткого разбиение генерируется произвольно.
* Степень исхода вершины информационного графа ( для одной интерации): 2 (3 - с учетом, если выходные данные пошли на следующую итерацию).

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

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

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

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

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

Проведём исследование масштабируемости параллельной реализации нечеткого алгоритма С-средних.
Исследование проводилось на суперкомпьютере "Ломоносов"<ref name="Lom">Воеводин Вл., Жуматий С., Соболев С., Антонов А., Брызгалов П., Никитенко Д., Стефанов К., Воеводин Вад. Практика суперкомпьютера «Ломоносов» // Открытые системы, 2012, N 7, С. 36-39.</ref> [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета].
Была исследована собственная параллельная реализация алгоритма, написанная на языке C++ с использованием стандарта MPI. Сборка программы производилась при помощи компилятора компании Intel версии 13.1.0 с использованием библиотеки intelMPI версии 4.1.0 . Расчеты проводились в разделе test на узлах со следующими характеристиками: количество GPU - 0, количество ядер - 8 ядер архитектуры x86, количество памяти - 12 Гб.

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

* число процессоров [1 : 128];
* размер матрицы [10000 : 80000].

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

* минимальная эффективность реализации 0,33%;
* максимальная эффективность реализации 9,4%.

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

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

Построим оценки масштабируемости выбранной реализации нечеткого алгоритма С-средних:
* По числу процессов: 0.007. При увеличении числа процессов эффективность на рассмотренной области изменений параметров запуска увеличивается.
* По размеру задачи: -0.0016. При увеличении размера задачи эффективность уменьшается.
* По двум направлениям: 0,000077. При рассмотрении увеличения как вычислительной сложности, так и числа процессов на всей рассмотренной области значений эффективность увеличивается, однако скорость увеличения эффективности небольшая.

Была использована следующая реализация алгоритма.

#include <mpi.h>
#include <stdio.h>
#include <iostream>
#include <stdlib.h>
#include <math.h>
#include <string.h>
#include <time.h>
using namespace std;
double **x; //input matrix of size (n x x_dim)
int n;
int x_dim;
double **centroids; //cluster centroids matrix of size (n_cluster x x_dim)
int n_cluster; // number of clusters
double **w; //probability matrix of size (n x n_cluster)
double **dist; //distances matrix of size (n x n_cluster)
double eps; //max error
double m; //parameter of algo
int max_iter; // max num of iterations
double **num;
double *den;
double *allden;
double *err;
double *total_err;
int rank, size;
double ** generateZerosMatrix(int r, int c){
double ** arr = new double* [r];
for (int i = 0; i < r; ++i){
arr[i] = new double[c]();
}
return arr;
}
int generate_data()
{
//generate matrix
x = generateZerosMatrix(n, x_dim);
centroids = generateZerosMatrix(n_cluster, x_dim);
w = generateZerosMatrix(n, n_cluster);
dist = generateZerosMatrix(n, n_cluster);
num = generateZerosMatrix(n_cluster, x_dim);
//generate vectors
den = new double [n_cluster]();
allden = new double [n_cluster]();
//for stopping algorithm
err = new double;
total_err = new double;
srand(time(0));
//initialize w randomly with restrictions
for (int i = 0; i < n; ++i){
double sum = 0;
for (int j = 0; j < n_cluster; ++j){
w[i][j] = rand();
sum += w[i][j];
}
for (int j = 0; j < n_cluster; ++j){
w[i][j] /= sum;
}
}
//initialize x randomly
for (int i = 0; i < n; ++i)
for (int j = 0; j < x_dim; ++j)
x[i][j] = rand();
return 0;
}
double make_iteration() {
// calculate centroids centers
for (int i = rank; i < n; i+=size)
for (int j = 0; j < n_cluster; ++j){
double mu = pow(w[i][j], m);
den[j] += mu;
for (int k = 0; k < x_dim; ++k)
num[j][k] = mu * x[i][k];
}
MPI_Allreduce(den, allden, n_cluster, MPI_DOUBLE, MPI_SUM, MPI_COMM_WORLD);
for (int j=0; j < n_cluster; ++j)
MPI_Allreduce(num[j], centroids[j], x_dim, MPI_DOUBLE, MPI_SUM, MPI_COMM_WORLD);
for (int i = 0; i < n_cluster; ++i)
for (int j = 0; j < x_dim; ++j)
centroids[i][j] /= allden[i];
// calculate distances and probabilities, check stop conditions
double err = 0.0;
for (int i = rank; i < n; i+=size)
for (int j = 0; j < n_cluster; ++j){
for (int k = 0; k < x_dim; ++k)
dist[i][j] += (x[i][k] - centroids[j][k]) * (x[i][k] - centroids[j][k]);
double w_prev = w[i][j];
for (int k = 0; k < n_cluster; ++k)
w[i][j] += dist[i][j] / dist[i][k];
w[i][j] = 1.0 / pow(w[i][j], 1.0 / (m - 1));
err = fmax(err, abs(w_prev - w[i][j]));
}
return err;
}
int FCM(){
*total_err = eps+1;
int cur_iter = 0;
while (cur_iter < max_iter && *total_err > eps){
*err = make_iteration();
MPI_Allreduce(err, total_err, 1, MPI_DOUBLE, MPI_MAX, MPI_COMM_WORLD);
cur_iter++;
}
return cur_iter;
}
void clearMatrix(double ** matr, int r, int c){
for (int i = 0; i < r; ++i){
delete [] matr[i];
}
delete [] matr;
}
int memory_free(){
clearMatrix(x, n, x_dim);
clearMatrix(centroids, n_cluster, x_dim);
clearMatrix(w, n_cluster, n);
clearMatrix(num, n_cluster, x_dim);
clearMatrix(dist, n, n_cluster);
delete [] den;
delete [] allden;
delete err;
delete total_err;
return 0;
}
int main(int argc, char **argv){
MPI_Init(&argc, &argv);
MPI_Comm_size(MPI_COMM_WORLD, &size);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
int n_repeat = strtol(argv[1], NULL, 10);
int nx_min = strtol(argv[2], NULL, 10);
int nx_max = strtol(argv[3], NULL, 10);
int step = strtol(argv[4], NULL, 10);
x_dim = strtol(argv[5], NULL, 10);
m = strtod(argv[6], NULL);
n_cluster = strtol(argv[7], NULL, 10);
max_iter = strtol(argv[8], NULL, 10);
eps = strtod(argv[9], NULL);
//for all input matrix sizes
for (n = nx_min; n <= nx_max; n += step){
double start, finish, time_elapsed_iter=0;
int total_iterations = 0;
//repeat for getting mean value
for (int i = 0; i < n_repeat; ++i) {
generate_data();
MPI_Barrier(MPI_COMM_WORLD);
start = MPI_Wtime();
total_iterations += FCM();
finish = MPI_Wtime();
memory_free();
time_elapsed_iter += (finish-start);
}
time_elapsed_iter /= total_iterations;
if (rank == 0) {
cout << n << " " << size << " " << time_elapsed_iter << endl;
}
}
MPI_Finalize();
}

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

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

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

* Реализация алгоритма на POSTGRESQL: http://num-meth.srcc.msu.ru/zhurnal/tom_2012/pdf/v13r207.pdf
* Библиотека для MATLAB: http://www.mathworks.com/help/fuzzy/fcm.html (распространяется на коммерческой основе)

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

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

2016-12-18T19:21:03Z

Yushin:

{{Assignment|{{REVISIONUSER}}}}

{{algorithm
| name = Нечеткий алгоритм C средних
| serial_complexity = <math>O(Mdc^2i)</math>, <math>i</math> - количество итераций
| input_data = <math>M*d</math>, [количество наблюдений * размерность]
| output_data = <math>M*c</math>, [количество наблюдений * количество кластеров]
| pf_height = <math>2i</math>
| pf_width = <math>n</math>
}}

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

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

== Общее описание алгоритма ==
Кластеризация - это объединение объектов в группы (кластеры) на основе схожести признаков для объектов одной группы и отличий между группами. Нечеткий алгоритм C Средних (Fuzzy C-means, FCM) - алгоритм кластеризации, позволяющий объектам принадлежать с различной степенью нескольким кластерам одновременно. Впервые алгоритм был предложен J.C. Dunn в 1973 <ref>[http://www.tandfonline.com/doi/abs/10.1080/01969727308546046 | J. C. Dunn. A Fuzzy Relative of the ISODATA Process and Its Use in Detecting Compact Well-Separated Clusters. Journal of Cybernetics, volume 3,1973 - Issue 3, pp 32-57]</ref>. Нечеткое разбиение позволяет просто решить проблему объектов кластеризации, расположенных на границе двух кластеров - им назначают степени принадлежностей равные 0.5.

Входные данные алгоритма: набор векторов, которые следует кластеризовать.

Параметры алгоритма: <math>c</math> - количество кластеров;<math>m >= 1</math> - экспоненциальный вес, определяющий нечеткость кластеров; <math>\varepsilon</math> - параметр останова алгоритма.

Выходные данные: матрица вероятностей принадлежности векторов кластерам.

Краткое описание алгоритма:

* Задать параметры алгоритма.

* Сгенерировать случайную матрицу принадлежностей векторов кластерам (матрицу нечеткого разбиения).

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

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

Пусть <math> W = w_{ij} \in[0,1],\; i = 1, ..., M, \; j = 1, ..., c</math> - матрица разбиения, где <math>w_{i,j}</math> - степень принадлежности объекта <math>i</math> к кластеру <math>j</math>; <math>c</math> - количество кластеров, <math>M</math> - количество векторов.

При этом элементы матрицы должны удовлетворять условиям:

* <math>\sum_{j = 1}^c w_{ij} = 1, i = 1, ..., M</math>                <math>(1)</math>
* <math>0 < \sum_{i = 1}^M w_{ij} < M, j = 1, ..., c</math>       <math>(2)</math>

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

1) Задаем параметры алгоритма: <math>c</math> - количество кластеров; <math>m >= 1</math> - экспоненциальный вес, определяющий нечеткость кластеров; <math>\varepsilon > 0</math> - параметр останова алгоритма.

2) Генерируем случайным образом матрицу нечеткого разбиения с учетом условий <math>(1)</math> и <math>(2)</math>

3) Рассчитываем центроиды (центры кластеров): <math>V_j = {{\sum_{i=1}^M w_{ij}^m * X_i} \over {\sum_{i=1}^M w_{ij}^m}}, j = 1, ..., c</math>

4) Рассчитываем расстояния между объектами <math>X</math> и центроидами:

<math>D_{ij} = {||X_i - V_j||}, i = 1,...,M; j = 1,...,c </math>

5) Пересчет элементов матрицы разбиения:

при <math>D_{ij} >0</math> : <math>w_{ij} = {{1}\over {{ (\sum_{k=1}^c {{D_{ij}}\over{D_{ik}}} ) }^{2/(m-1)}}}, j = 1,...,c</math>

при <math>D_{ij} =0</math> : <math>w_{ij} = \delta_{ij}, j = 1,...,c</math>, где <math>\delta_{ij}</math> - символ Кронекера

6) Если <math>|| F - F^{*} || < \varepsilon </math>, где <math>F^{*}</math> - матрица нечеткого разбиения предыдущей итерации, то идем далее, иначе возвращаемся на пункт 3.

7) Конец.

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

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

* Поиск <math>V_j</math> - расчет центроидов (пункт 3 алгоритма)
* Нахождение <math>D_{ij}</math> - расстояний между объектами (пункт 4 алгоритма)
* Пересчет <math>w_{ij}</math> - элементов матрицы разбиения (пункт 5 алгоритма)

== Макроструктура алгоритма ==
Основные шаги при реализации алгоритма
* Генерация случайной матрицы размера <math>M</math> на где <math>c</math>, проверка условий
* Расчет центроидов – по сути, скалярное произведение с нормировкой
* Расчет расстояний – в общепринятом случае является скалярным произведением
* Пересчет матрицы – по сути, скалярное произведение
* Проверка условий останова – вычисление нормы

== Схема реализации последовательного алгоритма ==
float ** FuzzyCMeans (float** X, c, m, eps){
n = X.size();
r = X[0].size();
centers = generateZeroFill(c, r)
Wprev = genetateRandFill(n, c);
W = Wprev;
while (true){
// обновляем центры кластеров
for (int i=0; i<c; i++){
float * num = new float []();
float den = 0;
for (int j=0; j<n; j++){
num += pow(W[j][i], m) * X[j];
den+=pow(W[j][i], m);
}
centers[i] = num / den;
}
//обновляем вероятности W и считаем расстояние между матрицами W и Wprev
float max_diff = 0;
for (int i=0; i<n; i++)
for (int j=0; j<c; j++){
total = 0;
for (int m=0; m<с; m++)
total += pow(distance(X[i], centers[j]) / distance(X[i], centers[m]), 2/(m-1));
W[i][j] = 1/total;
max_diff = max(abs(Wprev[i][j]-W[i][j]), max_diff);
Wprev[i][j] = W[i][j];
}
if (max_diff < eps):
break;
}
return W;
}

== Последовательная сложность алгоритма ==
Последовательная сложность алгоритма состоит из сложности каждой итерации умноженной на их количество. Так как число итераций заранее неизвестно и зависит от входных параметров, рассмотрим сложность на каждой итерации. Наибольшую сложность представляет собой пересчет матрицы, сложность которого <math>O(c^2 nd)</math> (по сравнению со сложностью <math>O(cnd)</math> расчета расстояний, вычисления центроидов и проверки условия останова). Итого общая сложность алгоритма <math>O(c^2 ndi)</math>

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

'''Первый ярус''' состоит из <math>M</math> параллельных операций 1, 2, совершаемых в цикле <math>c</math> раз для каждого кластера.

'''Операция 1''': <math>w_{ij}^m</math>, где <math>j</math> - номер итерации в цикле, <math>i</math> - номер параллельной ветви.

'''Операция 2''': <math>w_{ij}^m*X_i</math>

Здесь <math>j</math> - номер итерации в цикле, <math>i</math> - номер параллельной ветви.

На выходе из каждой ветки получаем вектор размера <math>1</math> x <math>c</math> и матрицу размера <math>d</math> x <math>c</math>.
Далее совершаем поэлементное сложение векторов и матриц соответственно, а затем делим каждый столбец в матрице на соответствующий элемент в векторе.

'''Второй ярус''' состоит их <math>M</math> параллельных операций 3, 4, 5 также совершаемых в цикле <math>c</math> раз.

'''Операция 3''': обновление значения <math>w_{ij}</math> по указанной в разделе 1.2 в пункте 5 формуле.

'''Операция 4''': <math>maximum = max(|w_{ij} - w_{ij}^{prev}|, maximum)</math>.

'''Операция 5''': <math>w_{ij}^{prev} = w_{ij}</math>.

Здесь <math>j</math> - номер итерации в цикле, <math>i</math> - номер параллельной ветви.

На выходе из каждой ветки получаем число <math>maximum</math>. Далее находим максимальное значение из полученных величин для каждой ветки. Затем проверяем условие останова алгоритма.

[[File:Scheme3.JPG]]

== Ресурс параллелизма алгоритма ==
Параллельная сложность алгоритма: <math>M*c^2*i</math>. Такая сложность получается за счет распараллеливания на каждом ярусе <math>M</math> операций. Иерархическая структура параллелизма подробно описана в [[#Информационный граф|п.1.7]].

В алгоритме не возникает скошенного параллелизма.

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

* Входные данные алгоритма: набор векторов <math>x_i</math> размерности <math>d</math>, где <math>i = 1,...,M</math>; <math>M</math> - количество векторов.
* Объем входных данных: <math>M*d</math> , [количество наблюдений * размерность].
* Выходные данные алгоритма: матрица вероятностей принадлежности векторов кластерам <math>M</math> на <math>c</math>.
* Объем выходных данных: <math>M*c</math> , [количество наблюдений * количество кластеров].

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

* Соотношение последовательной и параллельной формы алгоритма: <math>M</math>
* Вычислительная мощность: <math>{dc^2i} \over {c+d}</math>.
* Устойчивость: алгоритм не является устойчивым, поэтому существует много исследований о том, как первоначально выбрать параметры кластеризации.
* Сбалансированность: в данном алгоритме операция умножения доминирует над операцией сложения. Операции между параллельными ветвями сбалансированны.
* Детерминированность: алгоритм не является детерминированным, так как матрица нечеткого разбиение генерируется произвольно.
* Степень исхода вершины информационного графа ( для одной интерации): 2 (3 - с учетом, если выходные данные пошли на следующую итерацию).

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

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

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

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

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

Проведём исследование масштабируемости параллельной реализации нечеткого алгоритма С-средних.
Исследование проводилось на суперкомпьютере "Ломоносов"<ref name="Lom">Воеводин Вл., Жуматий С., Соболев С., Антонов А., Брызгалов П., Никитенко Д., Стефанов К., Воеводин Вад. Практика суперкомпьютера «Ломоносов» // Открытые системы, 2012, N 7, С. 36-39.</ref> [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета].
Была исследована собственная параллельная реализация алгоритма, написанная на языке C++ с использованием стандарта MPI. Сборка программы производилась при помощи компилятора компании Intel версии 13.1.0 с использованием библиотеки intelMPI версии 4.1.0 . Расчеты проводились в разделе test на узлах со следующими характеристиками: количество GPU - 0, количество ядер - 8 ядер архитектуры x86, количество памяти - 12 Гб.

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

* число процессоров [1 : 128];
* размер матрицы [10000 : 80000].

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

* минимальная эффективность реализации 0,33%;
* максимальная эффективность реализации 9,4%.

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

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

Построим оценки масштабируемости выбранной реализации нечеткого алгоритма С-средних:
* По числу процессов: 0.007. При увеличении числа процессов эффективность на рассмотренной области изменений параметров запуска увеличивается.
* По размеру задачи: -0.0016. При увеличении размера задачи эффективность уменьшается.
* По двум направлениям: 0,000077. При рассмотрении увеличения как вычислительной сложности, так и числа процессов на всей рассмотренной области значений эффективность увеличивается, однако скорость увеличения эффективности небольшая.

Была использована следующая реализация алгоритма.

#include <mpi.h>
#include <stdio.h>
#include <iostream>
#include <stdlib.h>
#include <math.h>
#include <string.h>
#include <time.h>
using namespace std;
double **x; //input matrix of size (n x x_dim)
int n;
int x_dim;
double **centroids; //cluster centroids matrix of size (n_cluster x x_dim)
int n_cluster; // number of clusters
double **w; //probability matrix of size (n x n_cluster)
double **dist; //distances matrix of size (n x n_cluster)
double eps; //max error
double m; //parameter of algo
int max_iter; // max num of iterations
double **num;
double *den;
double *allden;
double *err;
double *total_err;
int rank, size;
double ** generateZerosMatrix(int r, int c){
double ** arr = new double* [r];
for (int i = 0; i < r; ++i){
arr[i] = new double[c]();
}
return arr;
}
int generate_data()
{
//generate matrix
x = generateZerosMatrix(n, x_dim);
centroids = generateZerosMatrix(n_cluster, x_dim);
w = generateZerosMatrix(n, n_cluster);
dist = generateZerosMatrix(n, n_cluster);
num = generateZerosMatrix(n_cluster, x_dim);
//generate vectors
den = new double [n_cluster]();
allden = new double [n_cluster]();
//for stopping algorithm
err = new double;
total_err = new double;
srand(time(0));
//initialize w randomly with restrictions
for (int i = 0; i < n; ++i){
double sum = 0;
for (int j = 0; j < n_cluster; ++j){
w[i][j] = rand();
sum += w[i][j];
}
for (int j = 0; j < n_cluster; ++j){
w[i][j] /= sum;
}
}
//initialize x randomly
for (int i = 0; i < n; ++i)
for (int j = 0; j < x_dim; ++j)
x[i][j] = rand();
return 0;
}
double make_iteration() {
// calculate centroids centers
for (int i = rank; i < n; i+=size)
for (int j = 0; j < n_cluster; ++j){
double mu = pow(w[i][j], m);
den[j] += mu;
for (int k = 0; k < x_dim; ++k)
num[j][k] = mu * x[i][k];
}
MPI_Allreduce(den, allden, n_cluster, MPI_DOUBLE, MPI_SUM, MPI_COMM_WORLD);
for (int j=0; j < n_cluster; ++j)
MPI_Allreduce(num[j], centroids[j], x_dim, MPI_DOUBLE, MPI_SUM, MPI_COMM_WORLD);
for (int i = 0; i < n_cluster; ++i)
for (int j = 0; j < x_dim; ++j)
centroids[i][j] /= allden[i];
// calculate distances and probabilities, check stop conditions
double err = 0.0;
for (int i = rank; i < n; i+=size)
for (int j = 0; j < n_cluster; ++j){
for (int k = 0; k < x_dim; ++k)
dist[i][j] += (x[i][k] - centroids[j][k]) * (x[i][k] - centroids[j][k]);
double w_prev = w[i][j];
for (int k = 0; k < n_cluster; ++k)
w[i][j] += dist[i][j] / dist[i][k];
w[i][j] = 1.0 / pow(w[i][j], 1.0 / (m - 1));
err = fmax(err, abs(w_prev - w[i][j]));
}
return err;
}
int FCM(){
*total_err = eps+1;
int cur_iter = 0;
while (cur_iter < max_iter && *total_err > eps){
*err = make_iteration();
MPI_Allreduce(err, total_err, 1, MPI_DOUBLE, MPI_MAX, MPI_COMM_WORLD);
cur_iter++;
}
return cur_iter;
}
void clearMatrix(double ** matr, int r, int c){
for (int i = 0; i < r; ++i){
delete [] matr[i];
}
delete [] matr;
}
int memory_free(){
clearMatrix(x, n, x_dim);
clearMatrix(centroids, n_cluster, x_dim);
clearMatrix(w, n_cluster, n);
clearMatrix(num, n_cluster, x_dim);
clearMatrix(dist, n, n_cluster);
delete [] den;
delete [] allden;
delete err;
delete total_err;
return 0;
}
int main(int argc, char **argv){
MPI_Init(&argc, &argv);
MPI_Comm_size(MPI_COMM_WORLD, &size);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
int n_repeat = strtol(argv[1], NULL, 10);
int nx_min = strtol(argv[2], NULL, 10);
int nx_max = strtol(argv[3], NULL, 10);
int step = strtol(argv[4], NULL, 10);
x_dim = strtol(argv[5], NULL, 10);
m = strtod(argv[6], NULL);
n_cluster = strtol(argv[7], NULL, 10);
max_iter = strtol(argv[8], NULL, 10);
eps = strtod(argv[9], NULL);
//for all input matrix sizes
for (n = nx_min; n <= nx_max; n += step){
double start, finish, time_elapsed_iter=0;
int total_iterations = 0;
//repeat for getting mean value
for (int i = 0; i < n_repeat; ++i) {
generate_data();
MPI_Barrier(MPI_COMM_WORLD);
start = MPI_Wtime();
total_iterations += FCM();
finish = MPI_Wtime();
memory_free();
time_elapsed_iter += (finish-start);
}
time_elapsed_iter /= total_iterations;
if (rank == 0) {
cout << n << " " << size << " " << time_elapsed_iter << endl;
}
}
MPI_Finalize();
}

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

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

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

* Реализация алгоритма на POSTGRESQL: http://num-meth.srcc.msu.ru/zhurnal/tom_2012/pdf/v13r207.pdf
* Библиотека для MATLAB: http://www.mathworks.com/help/fuzzy/fcm.html (распространяется на коммерческой основе)

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

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

2016-12-18T19:18:57Z

Yushin:

{{Assignment|{{REVISIONUSER}}}}

{{algorithm
| name = Нечеткий алгоритм C средних
| serial_complexity = <math>O(Mdc^2i)</math>, <math>i</math> - количество итераций
| input_data = <math>M*d</math>, [количество наблюдений * размерность]
| output_data = <math>M*c</math>, [количество наблюдений * количество кластеров]
| pf_height = <math>2i</math>
| pf_width = <math>n</math>
}}

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

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

== Общее описание алгоритма ==
Кластеризация - это объединение объектов в группы (кластеры) на основе схожести признаков для объектов одной группы и отличий между группами. Нечеткий алгоритм C Средних (Fuzzy C-means, FCM) - алгоритм кластеризации, позволяющий объектам принадлежать с различной степенью нескольким кластерам одновременно. Впервые алгоритм был предложен J.C. Dunn в 1973 <ref>[http://www.tandfonline.com/doi/abs/10.1080/01969727308546046 | J. C. Dunn. A Fuzzy Relative of the ISODATA Process and Its Use in Detecting Compact Well-Separated Clusters. Journal of Cybernetics, volume 3,1973 - Issue 3, pp 32-57]</ref>. Нечеткое разбиение позволяет просто решить проблему объектов, расположенных на границе двух кластеров - им назначают степени принадлежностей равные 0.5.

Входные данные алгоритма: набор векторов, которые следует кластеризовать.

Параметры алгоритма: <math>c</math> - количество кластеров;<math>m >= 1</math> - экспоненциальный вес, определяющий нечеткость кластеров; <math>\varepsilon</math> - параметр останова алгоритма.

Выходные данные: матрица вероятностей принадлежности векторов кластерам.

Краткое описание алгоритма:

* Задать параметры алгоритма.

* Сгенерировать случайную матрицу принадлежностей векторов кластерам (матрицу нечеткого разбиения).

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

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

Пусть <math> W = w_{ij} \in[0,1],\; i = 1, ..., M, \; j = 1, ..., c</math> - матрица разбиения, где <math>w_{i,j}</math> - степень принадлежности объекта <math>i</math> к кластеру <math>j</math>; <math>c</math> - количество кластеров, <math>M</math> - количество векторов.

При этом элементы матрицы должны удовлетворять условиям:

* <math>\sum_{j = 1}^c w_{ij} = 1, i = 1, ..., M</math>                <math>(1)</math>
* <math>0 < \sum_{i = 1}^M w_{ij} < M, j = 1, ..., c</math>       <math>(2)</math>

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

1) Задаем параметры алгоритма: <math>c</math> - количество кластеров; <math>m >= 1</math> - экспоненциальный вес, определяющий нечеткость кластеров; <math>\varepsilon > 0</math> - параметр останова алгоритма.

2) Генерируем случайным образом матрицу нечеткого разбиения с учетом условий <math>(1)</math> и <math>(2)</math>

3) Рассчитываем центроиды (центры кластеров): <math>V_j = {{\sum_{i=1}^M w_{ij}^m * X_i} \over {\sum_{i=1}^M w_{ij}^m}}, j = 1, ..., c</math>

4) Рассчитываем расстояния между объектами <math>X</math> и центроидами:

<math>D_{ij} = {||X_i - V_j||}, i = 1,...,M; j = 1,...,c </math>

5) Пересчет элементов матрицы разбиения:

при <math>D_{ij} >0</math> : <math>w_{ij} = {{1}\over {{ (\sum_{k=1}^c {{D_{ij}}\over{D_{ik}}} ) }^{2/(m-1)}}}, j = 1,...,c</math>

при <math>D_{ij} =0</math> : <math>w_{ij} = \delta_{ij}, j = 1,...,c</math>, где <math>\delta_{ij}</math> - символ Кронекера

6) Если <math>|| F - F^{*} || < \varepsilon </math>, где <math>F^{*}</math> - матрица нечеткого разбиения предыдущей итерации, то идем далее, иначе возвращаемся на пункт 3.

7) Конец.

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

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

* Поиск <math>V_j</math> - расчет центроидов (пункт 3 алгоритма)
* Нахождение <math>D_{ij}</math> - расстояний между объектами (пункт 4 алгоритма)
* Пересчет <math>w_{ij}</math> - элементов матрицы разбиения (пункт 5 алгоритма)

== Макроструктура алгоритма ==
Основные шаги при реализации алгоритма
* Генерация случайной матрицы размера <math>M</math> на где <math>c</math>, проверка условий
* Расчет центроидов – по сути, скалярное произведение с нормировкой
* Расчет расстояний – в общепринятом случае является скалярным произведением
* Пересчет матрицы – по сути, скалярное произведение
* Проверка условий останова – вычисление нормы

== Схема реализации последовательного алгоритма ==
float ** FuzzyCMeans (float** X, c, m, eps){
n = X.size();
r = X[0].size();
centers = generateZeroFill(c, r)
Wprev = genetateRandFill(n, c);
W = Wprev;
while (true){
// обновляем центры кластеров
for (int i=0; i<c; i++){
float * num = new float []();
float den = 0;
for (int j=0; j<n; j++){
num += pow(W[j][i], m) * X[j];
den+=pow(W[j][i], m);
}
centers[i] = num / den;
}
//обновляем вероятности W и считаем расстояние между матрицами W и Wprev
float max_diff = 0;
for (int i=0; i<n; i++)
for (int j=0; j<c; j++){
total = 0;
for (int m=0; m<с; m++)
total += pow(distance(X[i], centers[j]) / distance(X[i], centers[m]), 2/(m-1));
W[i][j] = 1/total;
max_diff = max(abs(Wprev[i][j]-W[i][j]), max_diff);
Wprev[i][j] = W[i][j];
}
if (max_diff < eps):
break;
}
return W;
}

== Последовательная сложность алгоритма ==
Последовательная сложность алгоритма состоит из сложности каждой итерации умноженной на их количество. Так как число итераций заранее неизвестно и зависит от входных параметров, рассмотрим сложность на каждой итерации. Наибольшую сложность представляет собой пересчет матрицы, сложность которого <math>O(c^2 nd)</math> (по сравнению со сложностью <math>O(cnd)</math> расчета расстояний, вычисления центроидов и проверки условия останова). Итого общая сложность алгоритма <math>O(c^2 ndi)</math>

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

'''Первый ярус''' состоит из <math>M</math> параллельных операций 1, 2, совершаемых в цикле <math>c</math> раз для каждого кластера.

'''Операция 1''': <math>w_{ij}^m</math>, где <math>j</math> - номер итерации в цикле, <math>i</math> - номер параллельной ветви.

'''Операция 2''': <math>w_{ij}^m*X_i</math>

Здесь <math>j</math> - номер итерации в цикле, <math>i</math> - номер параллельной ветви.

На выходе из каждой ветки получаем вектор размера <math>1</math> x <math>c</math> и матрицу размера <math>d</math> x <math>c</math>.
Далее совершаем поэлементное сложение векторов и матриц соответственно, а затем делим каждый столбец в матрице на соответствующий элемент в векторе.

'''Второй ярус''' состоит их <math>M</math> параллельных операций 3, 4, 5 также совершаемых в цикле <math>c</math> раз.

'''Операция 3''': обновление значения <math>w_{ij}</math> по указанной в разделе 1.2 в пункте 5 формуле.

'''Операция 4''': <math>maximum = max(|w_{ij} - w_{ij}^{prev}|, maximum)</math>.

'''Операция 5''': <math>w_{ij}^{prev} = w_{ij}</math>.

Здесь <math>j</math> - номер итерации в цикле, <math>i</math> - номер параллельной ветви.

На выходе из каждой ветки получаем число <math>maximum</math>. Далее находим максимальное значение из полученных величин для каждой ветки. Затем проверяем условие останова алгоритма.

[[File:Scheme3.JPG]]

== Ресурс параллелизма алгоритма ==
Параллельная сложность алгоритма: <math>M*c^2*i</math>. Такая сложность получается за счет распараллеливания на каждом ярусе <math>M</math> операций. Иерархическая структура параллелизма подробно описана в [[#Информационный граф|п.1.7]].

В алгоритме не возникает скошенного параллелизма.

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

* Входные данные алгоритма: набор векторов <math>x_i</math> размерности <math>d</math>, где <math>i = 1,...,M</math>; <math>M</math> - количество векторов.
* Объем входных данных: <math>M*d</math> , [количество наблюдений * размерность].
* Выходные данные алгоритма: матрица вероятностей принадлежности векторов кластерам <math>M</math> на <math>c</math>.
* Объем выходных данных: <math>M*c</math> , [количество наблюдений * количество кластеров].

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

* Соотношение последовательной и параллельной формы алгоритма: <math>M</math>
* Вычислительная мощность: <math>{dc^2i} \over {c+d}</math>.
* Устойчивость: алгоритм не является устойчивым, поэтому существует много исследований о том, как первоначально выбрать параметры кластеризации.
* Сбалансированность: в данном алгоритме операция умножения доминирует над операцией сложения. Операции между параллельными ветвями сбалансированны.
* Детерминированность: алгоритм не является детерминированным, так как матрица нечеткого разбиение генерируется произвольно.
* Степень исхода вершины информационного графа ( для одной интерации): 2 (3 - с учетом, если выходные данные пошли на следующую итерацию).

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

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

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

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

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

Проведём исследование масштабируемости параллельной реализации нечеткого алгоритма С-средних.
Исследование проводилось на суперкомпьютере "Ломоносов"<ref name="Lom">Воеводин Вл., Жуматий С., Соболев С., Антонов А., Брызгалов П., Никитенко Д., Стефанов К., Воеводин Вад. Практика суперкомпьютера «Ломоносов» // Открытые системы, 2012, N 7, С. 36-39.</ref> [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета].
Была исследована собственная параллельная реализация алгоритма, написанная на языке C++ с использованием стандарта MPI. Сборка программы производилась при помощи компилятора компании Intel версии 13.1.0 с использованием библиотеки intelMPI версии 4.1.0 . Расчеты проводились в разделе test на узлах со следующими характеристиками: количество GPU - 0, количество ядер - 8 ядер архитектуры x86, количество памяти - 12 Гб.

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

* число процессоров [1 : 128];
* размер матрицы [10000 : 80000].

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

* минимальная эффективность реализации 0,33%;
* максимальная эффективность реализации 9,4%.

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

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

Построим оценки масштабируемости выбранной реализации нечеткого алгоритма С-средних:
* По числу процессов: 0.007. При увеличении числа процессов эффективность на рассмотренной области изменений параметров запуска увеличивается.
* По размеру задачи: -0.0016. При увеличении размера задачи эффективность уменьшается.
* По двум направлениям: 0,000077. При рассмотрении увеличения как вычислительной сложности, так и числа процессов на всей рассмотренной области значений эффективность увеличивается, однако скорость увеличения эффективности небольшая.

Была использована следующая реализация алгоритма.

#include <mpi.h>
#include <stdio.h>
#include <iostream>
#include <stdlib.h>
#include <math.h>
#include <string.h>
#include <time.h>
using namespace std;
double **x; //input matrix of size (n x x_dim)
int n;
int x_dim;
double **centroids; //cluster centroids matrix of size (n_cluster x x_dim)
int n_cluster; // number of clusters
double **w; //probability matrix of size (n x n_cluster)
double **dist; //distances matrix of size (n x n_cluster)
double eps; //max error
double m; //parameter of algo
int max_iter; // max num of iterations
double **num;
double *den;
double *allden;
double *err;
double *total_err;
int rank, size;
double ** generateZerosMatrix(int r, int c){
double ** arr = new double* [r];
for (int i = 0; i < r; ++i){
arr[i] = new double[c]();
}
return arr;
}
int generate_data()
{
//generate matrix
x = generateZerosMatrix(n, x_dim);
centroids = generateZerosMatrix(n_cluster, x_dim);
w = generateZerosMatrix(n, n_cluster);
dist = generateZerosMatrix(n, n_cluster);
num = generateZerosMatrix(n_cluster, x_dim);
//generate vectors
den = new double [n_cluster]();
allden = new double [n_cluster]();
//for stopping algorithm
err = new double;
total_err = new double;
srand(time(0));
//initialize w randomly with restrictions
for (int i = 0; i < n; ++i){
double sum = 0;
for (int j = 0; j < n_cluster; ++j){
w[i][j] = rand();
sum += w[i][j];
}
for (int j = 0; j < n_cluster; ++j){
w[i][j] /= sum;
}
}
//initialize x randomly
for (int i = 0; i < n; ++i)
for (int j = 0; j < x_dim; ++j)
x[i][j] = rand();
return 0;
}
double make_iteration() {
// calculate centroids centers
for (int i = rank; i < n; i+=size)
for (int j = 0; j < n_cluster; ++j){
double mu = pow(w[i][j], m);
den[j] += mu;
for (int k = 0; k < x_dim; ++k)
num[j][k] = mu * x[i][k];
}
MPI_Allreduce(den, allden, n_cluster, MPI_DOUBLE, MPI_SUM, MPI_COMM_WORLD);
for (int j=0; j < n_cluster; ++j)
MPI_Allreduce(num[j], centroids[j], x_dim, MPI_DOUBLE, MPI_SUM, MPI_COMM_WORLD);
for (int i = 0; i < n_cluster; ++i)
for (int j = 0; j < x_dim; ++j)
centroids[i][j] /= allden[i];
// calculate distances and probabilities, check stop conditions
double err = 0.0;
for (int i = rank; i < n; i+=size)
for (int j = 0; j < n_cluster; ++j){
for (int k = 0; k < x_dim; ++k)
dist[i][j] += (x[i][k] - centroids[j][k]) * (x[i][k] - centroids[j][k]);
double w_prev = w[i][j];
for (int k = 0; k < n_cluster; ++k)
w[i][j] += dist[i][j] / dist[i][k];
w[i][j] = 1.0 / pow(w[i][j], 1.0 / (m - 1));
err = fmax(err, abs(w_prev - w[i][j]));
}
return err;
}
int FCM(){
*total_err = eps+1;
int cur_iter = 0;
while (cur_iter < max_iter && *total_err > eps){
*err = make_iteration();
MPI_Allreduce(err, total_err, 1, MPI_DOUBLE, MPI_MAX, MPI_COMM_WORLD);
cur_iter++;
}
return cur_iter;
}
void clearMatrix(double ** matr, int r, int c){
for (int i = 0; i < r; ++i){
delete [] matr[i];
}
delete [] matr;
}
int memory_free(){
clearMatrix(x, n, x_dim);
clearMatrix(centroids, n_cluster, x_dim);
clearMatrix(w, n_cluster, n);
clearMatrix(num, n_cluster, x_dim);
clearMatrix(dist, n, n_cluster);
delete [] den;
delete [] allden;
delete err;
delete total_err;
return 0;
}
int main(int argc, char **argv){
MPI_Init(&argc, &argv);
MPI_Comm_size(MPI_COMM_WORLD, &size);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
int n_repeat = strtol(argv[1], NULL, 10);
int nx_min = strtol(argv[2], NULL, 10);
int nx_max = strtol(argv[3], NULL, 10);
int step = strtol(argv[4], NULL, 10);
x_dim = strtol(argv[5], NULL, 10);
m = strtod(argv[6], NULL);
n_cluster = strtol(argv[7], NULL, 10);
max_iter = strtol(argv[8], NULL, 10);
eps = strtod(argv[9], NULL);
//for all input matrix sizes
for (n = nx_min; n <= nx_max; n += step){
double start, finish, time_elapsed_iter=0;
int total_iterations = 0;
//repeat for getting mean value
for (int i = 0; i < n_repeat; ++i) {
generate_data();
MPI_Barrier(MPI_COMM_WORLD);
start = MPI_Wtime();
total_iterations += FCM();
finish = MPI_Wtime();
memory_free();
time_elapsed_iter += (finish-start);
}
time_elapsed_iter /= total_iterations;
if (rank == 0) {
cout << n << " " << size << " " << time_elapsed_iter << endl;
}
}
MPI_Finalize();
}

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

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

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

* Реализация алгоритма на POSTGRESQL: http://num-meth.srcc.msu.ru/zhurnal/tom_2012/pdf/v13r207.pdf
* Библиотека для MATLAB: http://www.mathworks.com/help/fuzzy/fcm.html (распространяется на коммерческой основе)

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

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

2016-11-09T18:09:05Z

Yushin:

{{Assignment}}

{{algorithm
| name = Нечеткий алгоритм C средних
| serial_complexity = <math>O(Mdc^2i)</math>, <math>i</math> - количество итераций
| input_data = <math>M*d</math>, [количество наблюдений * размерность]
| output_data = <math>M*c</math>, [количество наблюдений * количество кластеров]
| pf_height = <math>2i</math>
| pf_width = <math>n</math>
}}

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

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

== Общее описание алгоритма ==
Кластеризация - это объединение объектов в группы (кластеры) на основе схожести признаков для объектов одной группы и отличий между группами. Нечеткий алгоритм C Средних (Fuzzy C-means, FCM) - алгоритм кластеризации, позволяющий объектам принадлежать с различной степенью нескольким кластерам одновременно. Впервые алгоритм был предложен J.C. Dunn в 1973 <ref>[http://www.tandfonline.com/doi/abs/10.1080/01969727308546046 | J. C. Dunn. A Fuzzy Relative of the ISODATA Process and Its Use in Detecting Compact Well-Separated Clusters. Journal of Cybernetics, volume 3,1973 - Issue 3, pp 32-57]</ref>. Нечеткое разбиение позволяет просто решить проблему объектов, расположенных на границе двух кластеров - им назначают степени принадлежностей равные 0.5.

Входные данные алгоритма: набор векторов, которые следует кластеризовать.

Параметры алгоритма: <math>c</math> - количество кластеров; <math>m</math> - экспоненциальный вес; <math>\varepsilon</math> - параметр останова алгоритма.

Выходные данные: матрица вероятностей принадлежности векторов кластерам.

Краткое описание алгоритма:

* Задать параметры алгоритма.

* Сгенерировать случайную матрицу принадлежностей векторов кластерам (матрицу нечеткого разбиения).

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

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

Пусть <math> W = w_{ij} \in[0,1],\; i = 1, ..., M, \; j = 1, ..., c</math> - матрица разбиения, где <math>w_{i,j}</math> - степень принадлежности объекта <math>i</math> к кластеру <math>j</math>; <math>c</math> - количество кластеров, <math>M</math> - количество векторов.

При этом элементы матрицы должны удовлетворять условиям:

* <math>\sum_{j = 1}^c w_{ij} = 1, i = 1, ..., M</math>                <math>(1)</math>
* <math>0 < \sum_{i = 1}^M w_{ij} < M, j = 1, ..., c</math>       <math>(2)</math>

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

1) Задаем параметры алгоритма: <math>c</math> - количество кластеров; <math>m >= 1</math> - экспоненциальный вес, определяющий нечеткость кластеров; <math>\varepsilon > 0</math> - параметр останова алгоритма.

2) Генерируем случайным образом матрицу нечеткого разбиения с учетом условий <math>(1)</math> и <math>(2)</math>

3) Рассчитываем центроиды (центры кластеров): <math>V_j = {{\sum_{i=1}^M w_{ij}^m * X_i} \over {\sum_{i=1}^M w_{ij}^m}}, j = 1, ..., c</math>

4) Рассчитываем расстояния между объектами <math>X</math> и центроидами:

<math>D_{ij} = {||X_i - V_j||}, i = 1,...,M; j = 1,...,c </math>

5) Пересчет элементов матрицы разбиения:

при <math>D_{ij} >0</math> : <math>w_{ij} = {{1}\over {{ (\sum_{k=1}^c {{D_{ij}}\over{D_{ik}}} ) }^{2/(m-1)}}}, j = 1,...,c</math>

при <math>D_{ij} =0</math> : <math>w_{ij} = \delta_{ij}, j = 1,...,c</math>, где <math>\delta_{ij}</math> - символ Кронекера

6) Если <math>|| F - F^{*} || < \varepsilon </math>, где <math>F^{*}</math> - матрица нечеткого разбиения предыдущей итерации, то идем далее, иначе возвращаемся на пункт 3.

7) Конец.

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

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

* Поиск <math>V_j</math> - расчет центроидов (пункт 3 алгоритма)
* Нахождение <math>D_{ij}</math> - расстояний между объектами (пункт 4 алгоритма)
* Пересчет <math>w_{ij}</math> - элементов матрицы разбиения (пункт 5 алгоритма)

== Макроструктура алгоритма ==
Основные шаги при реализации алгоритма
* Генерация случайной матрицы размера <math>M</math> на где <math>c</math>, проверка условий
* Расчет центроидов – по сути, скалярное произведение с нормировкой
* Расчет расстояний – в общепринятом случае является скалярным произведением
* Пересчет матрицы – по сути, скалярное произведение
* Проверка условий останова – вычисление нормы

== Схема реализации последовательного алгоритма ==
float ** FuzzyCMeans (float** X, c, m, eps){
n = X.size();
r = X[0].size();
centers = generateZeroFill(c, r)
Wprev = genetateRandFill(n, c);
W = Wprev;
while (true){
// обновляем центры кластеров
for (int i=0; i<c; i++){
float * num = new float []();
float den = 0;
for (int j=0; j<n; j++){
num += pow(W[j][i], m) * X[j];
den+=pow(W[j][i], m);
}
centers[i] = num / den;
}
//обновляем вероятности W и считаем расстояние между матрицами W и Wprev
float max_diff = 0;
for (int i=0; i<n; i++)
for (int j=0; j<c; j++){
total = 0;
for (int m=0; m<с; m++)
total += pow(distance(X[i], centers[j]) / distance(X[i], centers[m]), 2/(m-1));
W[i][j] = 1/total;
max_diff = max(abs(Wprev[i][j]-W[i][j]), max_diff);
Wprev[i][j] = W[i][j];
}
if (max_diff < eps):
break;
}
return W;
}

== Последовательная сложность алгоритма ==
Последовательная сложность алгоритма состоит из сложности каждой итерации умноженной на их количество. Так как число итераций заранее неизвестно и зависит от входных параметров, рассмотрим сложность на каждой итерации. Наибольшую сложность представляет собой пересчет матрицы, сложность которого <math>O(c^2 nd)</math> (по сравнению со сложностью <math>O(cnd)</math> расчета расстояний, вычисления центроидов и проверки условия останова). Итого общая сложность алгоритма <math>O(c^2 ndi)</math>

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

'''Первый ярус''' состоит из <math>M</math> параллельных операций 1, 2, совершаемых в цикле <math>c</math> раз для каждого кластера.

'''Операция 1''': <math>w_{ij}^m</math>, где <math>j</math> - номер итерации в цикле, <math>i</math> - номер параллельной ветви.

'''Операция 2''': <math>w_{ij}^m*X_i</math>

Здесь <math>j</math> - номер итерации в цикле, <math>i</math> - номер параллельной ветви.

На выходе из каждой ветки получаем вектор размера <math>1</math> x <math>c</math> и матрицу размера <math>d</math> x <math>c</math>.
Далее совершаем поэлементное сложение векторов и матриц соответственно, а затем делим каждый столбец в матрице на соответствующий элемент в векторе.

'''Второй ярус''' состоит их <math>M</math> параллельных операций 3, 4, 5 также совершаемых в цикле <math>c</math> раз.

'''Операция 4''': обновление значения <math>w_{ij}</math> по указанной в разделе 1.2 в пункте 5 формуле.

'''Операция 5''': <math>maximum = max(|w_{ij} - w_{ij}^{prev}|, maximum)</math>.

'''Операция 6''': <math>w_{ij}^{prev} = w_{ij}</math>.

Здесь <math>j</math> - номер итерации в цикле, <math>i</math> - номер параллельной ветви.

На выходе из каждой ветки получаем число <math>maximum</math>. Далее находим максимальное значение из полученных величин для каждой ветки. Затем проверяем условие останова алгоритма.

[[File:Scheme3.JPG]]

== Ресурс параллелизма алгоритма ==
Параллельная сложность алгоритма: <math>M*c^2*i</math>. Такая сложность получается за счет распараллеливания на каждом ярусе <math>M</math> операций. Иерархическая структура параллелизма подробно описана в [[#Информационный граф|п.1.7]].

В алгоритме не возникает скошенного параллелизма.

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

* Входные данные алгоритма: набор векторов <math>x_i</math> размерности <math>d</math>, где <math>i = 1,...,M</math>; <math>M</math> - количество векторов.
* Объем входных данных: <math>M*d</math> , [количество наблюдений * размерность].
* Выходные данные алгоритма: матрица вероятностей принадлежности векторов кластерам <math>M</math> на <math>c</math>.
* Объем выходных данных: <math>M*c</math> , [количество наблюдений * количество кластеров].

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

* Соотношение последовательной и параллельной формы алгоритма: <math>M</math>
* Вычислительная мощность: <math>{dc^2i} \over {c+d}</math>.
* Устойчивость: алгоритм не является устойчивым, поэтому существует много исследований о том, как первоначально выбрать параметры кластеризации.
* Сбалансированность: в данном алгоритме операция умножения доминирует над операцией сложения. Операции между параллельными ветвями сбалансированны.
* Детерминированность: алгоритм не является детерминированным, так как матрица нечеткого разбиение генерируется произвольно.
* Степень исхода вершины информационного графа ( для одной интерации): 2 (3 - с учетом, если выходные данные пошли на следующую итерацию).

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

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

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

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

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

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

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

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

* Реализация алгоритма на POSTGRESQL: http://num-meth.srcc.msu.ru/zhurnal/tom_2012/pdf/v13r207.pdf
* Библиотека для MATLAB: http://www.mathworks.com/help/fuzzy/fcm.html (распространяется на коммерческой основе)

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

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

2016-11-09T18:08:15Z

Yushin:

{{algorithm
| name = Нечеткий алгоритм C средних
| serial_complexity = <math>O(Mdc^2i)</math>, <math>i</math> - количество итераций
| input_data = <math>M*d</math>, [количество наблюдений * размерность]
| output_data = <math>M*c</math>, [количество наблюдений * количество кластеров]
| pf_height = <math>2i</math>
| pf_width = <math>n</math>
}}

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

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

== Общее описание алгоритма ==
Кластеризация - это объединение объектов в группы (кластеры) на основе схожести признаков для объектов одной группы и отличий между группами. Нечеткий алгоритм C Средних (Fuzzy C-means, FCM) - алгоритм кластеризации, позволяющий объектам принадлежать с различной степенью нескольким кластерам одновременно. Впервые алгоритм был предложен J.C. Dunn в 1973 <ref>[http://www.tandfonline.com/doi/abs/10.1080/01969727308546046 | J. C. Dunn. A Fuzzy Relative of the ISODATA Process and Its Use in Detecting Compact Well-Separated Clusters. Journal of Cybernetics, volume 3,1973 - Issue 3, pp 32-57]</ref>. Нечеткое разбиение позволяет просто решить проблему объектов, расположенных на границе двух кластеров - им назначают степени принадлежностей равные 0.5.

Входные данные алгоритма: набор векторов, которые следует кластеризовать.

Параметры алгоритма: <math>c</math> - количество кластеров; <math>m</math> - экспоненциальный вес; <math>\varepsilon</math> - параметр останова алгоритма.

Выходные данные: матрица вероятностей принадлежности векторов кластерам.

Краткое описание алгоритма:

* Задать параметры алгоритма.

* Сгенерировать случайную матрицу принадлежностей векторов кластерам (матрицу нечеткого разбиения).

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

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

Пусть <math> W = w_{ij} \in[0,1],\; i = 1, ..., M, \; j = 1, ..., c</math> - матрица разбиения, где <math>w_{i,j}</math> - степень принадлежности объекта <math>i</math> к кластеру <math>j</math>; <math>c</math> - количество кластеров, <math>M</math> - количество векторов.

При этом элементы матрицы должны удовлетворять условиям:

* <math>\sum_{j = 1}^c w_{ij} = 1, i = 1, ..., M</math>                <math>(1)</math>
* <math>0 < \sum_{i = 1}^M w_{ij} < M, j = 1, ..., c</math>       <math>(2)</math>

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

1) Задаем параметры алгоритма: <math>c</math> - количество кластеров; <math>m >= 1</math> - экспоненциальный вес, определяющий нечеткость кластеров; <math>\varepsilon > 0</math> - параметр останова алгоритма.

2) Генерируем случайным образом матрицу нечеткого разбиения с учетом условий <math>(1)</math> и <math>(2)</math>

3) Рассчитываем центроиды (центры кластеров): <math>V_j = {{\sum_{i=1}^M w_{ij}^m * X_i} \over {\sum_{i=1}^M w_{ij}^m}}, j = 1, ..., c</math>

4) Рассчитываем расстояния между объектами <math>X</math> и центроидами:

<math>D_{ij} = {||X_i - V_j||}, i = 1,...,M; j = 1,...,c </math>

5) Пересчет элементов матрицы разбиения:

при <math>D_{ij} >0</math> : <math>w_{ij} = {{1}\over {{ (\sum_{k=1}^c {{D_{ij}}\over{D_{ik}}} ) }^{2/(m-1)}}}, j = 1,...,c</math>

при <math>D_{ij} =0</math> : <math>w_{ij} = \delta_{ij}, j = 1,...,c</math>, где <math>\delta_{ij}</math> - символ Кронекера

6) Если <math>|| F - F^{*} || < \varepsilon </math>, где <math>F^{*}</math> - матрица нечеткого разбиения предыдущей итерации, то идем далее, иначе возвращаемся на пункт 3.

7) Конец.

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

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

* Поиск <math>V_j</math> - расчет центроидов (пункт 3 алгоритма)
* Нахождение <math>D_{ij}</math> - расстояний между объектами (пункт 4 алгоритма)
* Пересчет <math>w_{ij}</math> - элементов матрицы разбиения (пункт 5 алгоритма)

== Макроструктура алгоритма ==
Основные шаги при реализации алгоритма
* Генерация случайной матрицы размера <math>M</math> на где <math>c</math>, проверка условий
* Расчет центроидов – по сути, скалярное произведение с нормировкой
* Расчет расстояний – в общепринятом случае является скалярным произведением
* Пересчет матрицы – по сути, скалярное произведение
* Проверка условий останова – вычисление нормы

== Схема реализации последовательного алгоритма ==
float ** FuzzyCMeans (float** X, c, m, eps){
n = X.size();
r = X[0].size();
centers = generateZeroFill(c, r)
Wprev = genetateRandFill(n, c);
W = Wprev;
while (true){
// обновляем центры кластеров
for (int i=0; i<c; i++){
float * num = new float []();
float den = 0;
for (int j=0; j<n; j++){
num += pow(W[j][i], m) * X[j];
den+=pow(W[j][i], m);
}
centers[i] = num / den;
}
//обновляем вероятности W и считаем расстояние между матрицами W и Wprev
float max_diff = 0;
for (int i=0; i<n; i++)
for (int j=0; j<c; j++){
total = 0;
for (int m=0; m<с; m++)
total += pow(distance(X[i], centers[j]) / distance(X[i], centers[m]), 2/(m-1));
W[i][j] = 1/total;
max_diff = max(abs(Wprev[i][j]-W[i][j]), max_diff);
Wprev[i][j] = W[i][j];
}
if (max_diff < eps):
break;
}
return W;
}

== Последовательная сложность алгоритма ==
Последовательная сложность алгоритма состоит из сложности каждой итерации умноженной на их количество. Так как число итераций заранее неизвестно и зависит от входных параметров, рассмотрим сложность на каждой итерации. Наибольшую сложность представляет собой пересчет матрицы, сложность которого <math>O(c^2 nd)</math> (по сравнению со сложностью <math>O(cnd)</math> расчета расстояний, вычисления центроидов и проверки условия останова). Итого общая сложность алгоритма <math>O(c^2 ndi)</math>

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

'''Первый ярус''' состоит из <math>M</math> параллельных операций 1, 2, совершаемых в цикле <math>c</math> раз для каждого кластера.

'''Операция 1''': <math>w_{ij}^m</math>, где <math>j</math> - номер итерации в цикле, <math>i</math> - номер параллельной ветви.

'''Операция 2''': <math>w_{ij}^m*X_i</math>

Здесь <math>j</math> - номер итерации в цикле, <math>i</math> - номер параллельной ветви.

На выходе из каждой ветки получаем вектор размера <math>1</math> x <math>c</math> и матрицу размера <math>d</math> x <math>c</math>.
Далее совершаем поэлементное сложение векторов и матриц соответственно, а затем делим каждый столбец в матрице на соответствующий элемент в векторе.

'''Второй ярус''' состоит их <math>M</math> параллельных операций 3, 4, 5 также совершаемых в цикле <math>c</math> раз.

'''Операция 4''': обновление значения <math>w_{ij}</math> по указанной в разделе 1.2 в пункте 5 формуле.

'''Операция 5''': <math>maximum = max(|w_{ij} - w_{ij}^{prev}|, maximum)</math>.

'''Операция 6''': <math>w_{ij}^{prev} = w_{ij}</math>.

Здесь <math>j</math> - номер итерации в цикле, <math>i</math> - номер параллельной ветви.

На выходе из каждой ветки получаем число <math>maximum</math>. Далее находим максимальное значение из полученных величин для каждой ветки. Затем проверяем условие останова алгоритма.

[[File:Scheme3.JPG]]

== Ресурс параллелизма алгоритма ==
Параллельная сложность алгоритма: <math>M*c^2*i</math>. Такая сложность получается за счет распараллеливания на каждом ярусе <math>M</math> операций. Иерархическая структура параллелизма подробно описана в [[#Информационный граф|п.1.7]].

В алгоритме не возникает скошенного параллелизма.

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

* Входные данные алгоритма: набор векторов <math>x_i</math> размерности <math>d</math>, где <math>i = 1,...,M</math>; <math>M</math> - количество векторов.
* Объем входных данных: <math>M*d</math> , [количество наблюдений * размерность].
* Выходные данные алгоритма: матрица вероятностей принадлежности векторов кластерам <math>M</math> на <math>c</math>.
* Объем выходных данных: <math>M*c</math> , [количество наблюдений * количество кластеров].

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

* Соотношение последовательной и параллельной формы алгоритма: <math>M</math>
* Вычислительная мощность: <math>{dc^2i} \over {c+d}</math>.
* Устойчивость: алгоритм не является устойчивым, поэтому существует много исследований о том, как первоначально выбрать параметры кластеризации.
* Сбалансированность: в данном алгоритме операция умножения доминирует над операцией сложения. Операции между параллельными ветвями сбалансированны.
* Детерминированность: алгоритм не является детерминированным, так как матрица нечеткого разбиение генерируется произвольно.
* Степень исхода вершины информационного графа ( для одной интерации): 2 (3 - с учетом, если выходные данные пошли на следующую итерацию).

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

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

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

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

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

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

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

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

* Реализация алгоритма на POSTGRESQL: http://num-meth.srcc.msu.ru/zhurnal/tom_2012/pdf/v13r207.pdf
* Библиотека для MATLAB: http://www.mathworks.com/help/fuzzy/fcm.html (распространяется на коммерческой основе)

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

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

2016-11-06T16:51:10Z

Yushin:

{{Assignment}}

{{algorithm
| name = Нечеткий алгоритм C средних
| serial_complexity = <math>O(Mdc^2i)</math>, <math>i</math> - количество итераций
| input_data = <math>M*d</math>, [количество наблюдений * размерность]
| output_data = <math>M*c</math>, [количество наблюдений * количество кластеров]
| pf_height = <math>2i</math>
| pf_width = <math>n</math>
}}

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

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

== Общее описание алгоритма ==
Кластеризация - это объединение объектов в группы (кластеры) на основе схожести признаков для объектов одной группы и отличий между группами. Нечеткий алгоритм C Средних (Fuzzy C-means, FCM) - алгоритм кластеризации, позволяющий объектам принадлежать с различной степенью нескольким кластерам одновременно. Впервые алгоритм был предложен J.C. Dunn в 1973 <ref>[http://www.tandfonline.com/doi/abs/10.1080/01969727308546046 | J. C. Dunn. A Fuzzy Relative of the ISODATA Process and Its Use in Detecting Compact Well-Separated Clusters. Journal of Cybernetics, volume 3,1973 - Issue 3, pp 32-57]</ref>. Нечеткое разбиение позволяет просто решить проблему объектов, расположенных на границе двух кластеров - им назначают степени принадлежностей равные 0.5.

Входные данные алгоритма: набор векторов, которые следует кластеризовать.

Параметры алгоритма: <math>c</math> - количество кластеров; <math>m</math> - экспоненциальный вес; <math>\varepsilon</math> - параметр останова алгоритма.

Выходные данные: матрица вероятностей принадлежности векторов кластерам.

Краткое описание алгоритма:

* Задать параметры алгоритма.

* Сгенерировать случайную матрицу принадлежностей векторов кластерам (матрицу нечеткого разбиения).

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

== Математическое описание алгоритма <ref>[http://it-claim.ru/Persons/Neyskiy/Article2_Neiskiy.pdf | Нейский И.М. Классификация и сравнение методов кластеризации.]</ref> ==

Пусть <math> W = w_{ij} \in[0,1],\; i = 1, ..., M, \; j = 1, ..., c</math> - матрица разбиения, где <math>w_{i,j}</math> - степень принадлежности объекта <math>i</math> к кластеру <math>j</math>; <math>c</math> - количество кластеров, <math>M</math> - количество векторов.

При этом элементы матрицы должны удовлетворять условиям:

* <math>\sum_{j = 1}^c w_{ij} = 1, i = 1, ..., M</math>                <math>(1)</math>
* <math>0 < \sum_{i = 1}^M w_{ij} < M, j = 1, ..., c</math>       <math>(2)</math>

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

1) Задаем параметры алгоритма: <math>c</math> - количество кластеров; <math>m >= 1</math> - экспоненциальный вес, определяющий нечеткость кластеров; <math>\varepsilon > 0</math> - параметр останова алгоритма.

2) Генерируем случайным образом матрицу нечеткого разбиения с учетом условий <math>(1)</math> и <math>(2)</math>

3) Рассчитываем центроиды (центры кластеров): <math>V_j = {{\sum_{i=1}^M w_{ij}^m * X_i} \over {\sum_{i=1}^M w_{ij}^m}}, j = 1, ..., c</math>

4) Рассчитываем расстояния между объектами <math>X</math> и центроидами:

<math>D_{ij} = {||X_i - V_j||}, i = 1,...,M; j = 1,...,c </math>

5) Пересчет элементов матрицы разбиения:

при <math>D_{ij} >0</math> : <math>w_{ij} = {{1}\over {{ (\sum_{k=1}^c {{D_{ij}}\over{D_{ik}}} ) }^{2/(m-1)}}}, j = 1,...,c</math>

при <math>D_{ij} =0</math> : <math>w_{ij} = \delta_{ij}, j = 1,...,c</math>, где <math>\delta_{ij}</math> - символ Кронекера

6) Если <math>|| F - F^{*} || < \varepsilon </math>, где <math>F^{*}</math> - матрица нечеткого разбиения предыдущей итерации, то идем далее, иначе возвращаемся на пункт 3.

7) Конец.

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

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

* Поиск <math>V_j</math> - расчет центроидов (пункт 3 алгоритма)
* Нахождение <math>D_{ij}</math> - расстояний между объектами (пункт 4 алгоритма)
* Пересчет <math>w_{ij}</math> - элементов матрицы разбиения (пункт 5 алгоритма)

== Макроструктура алгоритма ==
Основные шаги при реализации алгоритма
* Генерация случайной матрицы размера <math>M</math> на где <math>c</math>, проверка условий
* Расчет центроидов – по сути, скалярное произведение с нормировкой
* Расчет расстояний – в общепринятом случае является скалярным произведением
* Пересчет матрицы – по сути, скалярное произведение
* Проверка условий останова – вычисление нормы

== Схема реализации последовательного алгоритма ==
float ** FuzzyCMeans (float** X, c, m, eps){
n = X.size();
r = X[0].size();
centers = generateZeroFill(c, r)
Wprev = genetateRandFill(n, c);
W = Wprev;
while (true){
// обновляем центры кластеров
for (int i=0; i<c; i++){
float * num = new float []();
float den = 0;
for (int j=0; j<n; j++){
num += pow(W[j][i], m) * X[j];
den+=pow(W[j][i], m);
}
centers[i] = num / den;
}
//обновляем вероятности W и считаем расстояние между матрицами W и Wprev
float max_diff = 0;
for (int i=0; i<n; i++)
for (int j=0; j<c; j++){
total = 0;
for (int m=0; m<с; m++)
total += pow(distance(X[i], centers[j]) / distance(X[i], centers[m]), 2/(m-1));
W[i][j] = 1/total;
max_diff = max(abs(Wprev[i][j]-W[i][j]), max_diff);
Wprev[i][j] = W[i][j];
}
if (max_diff < eps):
break;
}
return W;
}

== Последовательная сложность алгоритма ==
Последовательная сложность алгоритма состоит из сложности каждой итерации умноженной на их количество. Так как число итераций заранее неизвестно и зависит от входных параметров, рассмотрим сложность на каждой итерации. Наибольшую сложность представляет собой пересчет матрицы, сложность которого <math>O(c^2 nd)</math> (по сравнению со сложностью <math>O(cnd)</math> расчета расстояний, вычисления центроидов и проверки условия останова). Итого общая сложность алгоритма <math>O(c^2 ndi)</math>

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

'''Первый ярус''' состоит из <math>M</math> параллельных операций 1, 2, совершаемых в цикле <math>c</math> раз для каждого кластера.

'''Операция 1''': <math>w_{ij}^m</math>, где <math>j</math> - номер итерации в цикле, <math>i</math> - номер параллельной ветви.

'''Операция 2''': <math>w_{ij}^m*X_i</math>

Здесь <math>j</math> - номер итерации в цикле, <math>i</math> - номер параллельной ветви.

На выходе из каждой ветки получаем вектор размера <math>1</math> x <math>c</math> и матрицу размера <math>d</math> x <math>c</math>.
Далее совершаем поэлементное сложение векторов и матриц соответственно, а затем делим каждый столбец в матрице на соответствующий элемент в векторе.

'''Второй ярус''' состоит их <math>M</math> параллельных операций 3, 4, 5 также совершаемых в цикле <math>c</math> раз.

'''Операция 4''': обновление значения <math>w_{ij}</math> по указанной в разделе 1.2 в пункте 5 формуле.

'''Операция 5''': <math>maximum = max(|w_{ij} - w_{ij}^{prev}|, maximum)</math>.

'''Операция 6''': <math>w_{ij}^{prev} = w_{ij}</math>.

Здесь <math>j</math> - номер итерации в цикле, <math>i</math> - номер параллельной ветви.

На выходе из каждой ветки получаем число <math>maximum</math>. Далее находим максимальное значение из полученных величин для каждой ветки. Затем проверяем условие останова алгоритма.

[[File:Scheme3.JPG]]

== Ресурс параллелизма алгоритма ==
Параллельная сложность алгоритма: <math>M*c^2*i</math>. Такая сложность получается за счет распараллеливания на каждом ярусе <math>M</math> операций. Иерархическая структура параллелизма подробно описана в [[#Информационный граф|п.1.7]].

В алгоритме не возникает скошенного параллелизма.

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

* Входные данные алгоритма: набор векторов <math>x_i</math> размерности <math>d</math>, где <math>i = 1,...,M</math>; <math>M</math> - количество векторов.
* Объем входных данных: <math>M*d</math> , [количество наблюдений * размерность].
* Выходные данные алгоритма: матрица вероятностей принадлежности векторов кластерам <math>M</math> на <math>c</math>.
* Объем выходных данных: <math>M*c</math> , [количество наблюдений * количество кластеров].

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

* Соотношение последовательной и параллельной формы алгоритма: <math>M</math>
* Вычислительная мощность: <math>{dc^2i} \over {c+d}</math>.
* Устойчивость: алгоритм не является устойчивым, поэтому существует много исследований о том, как первоначально выбрать параметры кластеризации.
* Сбалансированность: в данном алгоритме операция умножения доминирует над операцией сложения. Операции между параллельными ветвями сбалансированны.
* Детерминированность: алгоритм не является детерминированным, так как матрица нечеткого разбиение генерируется произвольно.
* Степень исхода вершины информационного графа ( для одной интерации): 2 (3 - с учетом, если выходные данные пошли на следующую итерацию).

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

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

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

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

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

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

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

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

* Реализация алгоритма на POSTGRESQL: http://num-meth.srcc.msu.ru/zhurnal/tom_2012/pdf/v13r207.pdf
* Библиотека для MATLAB: http://www.mathworks.com/help/fuzzy/fcm.html (распространяется на коммерческой основе)

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

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

2016-11-06T16:47:56Z

Yushin:

= Статья [[Нечеткий алгоритм C средних]] =
* Не указан вклад каждого автора [[Участник:Coctic|Coctic]] ([[Обсуждение участника:Coctic|обсуждение]]) 12:54, 25 октября 2016 (MSK)
** Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 10:55, 1 ноября 2016 (MSK)
* п. 1.2 номера формул следует выравнивать по правому краю, а не прилеплять вплотную к формуле [[Участник:Coctic|Coctic]] ([[Обсуждение участника:Coctic|обсуждение]]) 12:54, 25 октября 2016 (MSK)
** Условно исправлено. Форматирование сделано негодными средствами, но неясно, установлены ли средства (https://en.wikipedia.org/wiki/Help:Displaying_a_formula#Equation_numbering), чтобы сделать правильно [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 10:55, 1 ноября 2016 (MSK)
*** Пробовал сделать указанными Вами средствами - на этом ресурсе указанные Вами шаблоны не заработали [[Участник:Yushin|Павел Юшин]]
* п. 1.3 состоит из одного предложения и не дает достаточно информации [[Участник:Coctic|Coctic]] ([[Обсуждение участника:Coctic|обсуждение]]) 12:54, 25 октября 2016 (MSK)
** Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 10:55, 1 ноября 2016 (MSK)
* п. 1.7 приведенный рисунок не является информационным графом: не все дуги ориентированы, имеются циклы [[Участник:Coctic|Coctic]] ([[Обсуждение участника:Coctic|обсуждение]]) 12:54, 25 октября 2016 (MSK)
** Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 10:55, 1 ноября 2016 (MSK)
* п. 1.9 не приведено оценки объема входных и выходных данных [[Участник:Coctic|Coctic]] ([[Обсуждение участника:Coctic|обсуждение]]) 12:54, 25 октября 2016 (MSK)
** Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 10:55, 1 ноября 2016 (MSK)
* в разделе 2 отсутствуют необходимые пункты, п. 2.2 должен быть 2.7 [[Участник:Coctic|Coctic]] ([[Обсуждение участника:Coctic|обсуждение]]) 12:54, 25 октября 2016 (MSK)
** Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 10:55, 1 ноября 2016 (MSK)
* В списке литературы 1 ссылка - скопированный шаблон без реальной ссылки, 2 ссылка - просто URL без выходных данных источника [[Участник:Coctic|Coctic]] ([[Обсуждение участника:Coctic|обсуждение]]) 12:54, 25 октября 2016 (MSK)
** Исправлено частично. Ссылка 2 по-прежнему не имеет достаточных выходных данных [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 10:55, 1 ноября 2016 (MSK)
*** На сайте, где студентам выдавалось задание ( http://parallel.ru/ss16 ), данный материал предоставлялся в списке источников (номер [8]) в таком же виде, как он указан в данной статье [[Участник:Yushin|Павел Юшин]]

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

2016-10-28T16:34:36Z

Yushin:

{{algorithm
| name = Нечеткий алгоритм C средних
| serial_complexity = <math>O(Mdc^2i)</math>, <math>i</math> - количество итераций
| input_data = <math>M*d</math>, [количество наблюдений * размерность]
| output_data = <math>M*c</math>, [количество наблюдений * количество кластеров]
| pf_height = <math>2i</math>
| pf_width = <math>n</math>
}}

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

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

== Общее описание алгоритма ==
Кластеризация - это объединение объектов в группы (кластеры) на основе схожести признаков для объектов одной группы и отличий между группами. Нечеткий алгоритм C Средних (Fuzzy C-means, FCM) - алгоритм кластеризации, позволяющий объектам принадлежать с различной степенью нескольким кластерам одновременно. Впервые алгоритм был предложен J.C. Dunn в 1973 <ref>[http://www.tandfonline.com/doi/abs/10.1080/01969727308546046 | J. C. Dunn. A Fuzzy Relative of the ISODATA Process and Its Use in Detecting Compact Well-Separated Clusters. Journal of Cybernetics, volume 3,1973 - Issue 3, pp 32-57]</ref>. Нечеткое разбиение позволяет просто решить проблему объектов, расположенных на границе двух кластеров - им назначают степени принадлежностей равные 0.5.

Входные данные алгоритма: набор векторов, которые следует кластеризовать.

Параметры алгоритма: <math>c</math> - количество кластеров; <math>m</math> - экспоненциальный вес; <math>\varepsilon</math> - параметр останова алгоритма.

Выходные данные: матрица вероятностей принадлежности векторов кластерам.

Краткое описание алгоритма:

* Задать параметры алгоритма.

* Сгенерировать случайную матрицу принадлежностей векторов кластерам (матрицу нечеткого разбиения).

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

== Математическое описание алгоритма <ref>[http://it-claim.ru/Persons/Neyskiy/Article2_Neiskiy.pdf | Нейский И.М. Классификация и сравнение методов кластеризации.]</ref> ==

Пусть <math> W = w_{ij} \in[0,1],\; i = 1, ..., M, \; j = 1, ..., c</math> - матрица разбиения, где <math>w_{i,j}</math> - степень принадлежности объекта <math>i</math> к кластеру <math>j</math>; <math>c</math> - количество кластеров, <math>M</math> - количество векторов.

При этом элементы матрицы должны удовлетворять условиям:

* <math>\sum_{j = 1}^c w_{ij} = 1, i = 1, ..., M</math>                <math>(1)</math>
* <math>0 < \sum_{i = 1}^M w_{ij} < M, j = 1, ..., c</math>       <math>(2)</math>

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

1) Задаем параметры алгоритма: <math>c</math> - количество кластеров; <math>m >= 1</math> - экспоненциальный вес, определяющий нечеткость кластеров; <math>\varepsilon > 0</math> - параметр останова алгоритма.

2) Генерируем случайным образом матрицу нечеткого разбиения с учетом условий <math>(1)</math> и <math>(2)</math>

3) Рассчитываем центроиды (центры кластеров): <math>V_j = {{\sum_{i=1}^M w_{ij}^m * X_i} \over {\sum_{i=1}^M w_{ij}^m}}, j = 1, ..., c</math>

4) Рассчитываем расстояния между объектами <math>X</math> и центроидами:

<math>D_{ij} = {||X_i - V_j||}, i = 1,...,M; j = 1,...,c </math>

5) Пересчет элементов матрицы разбиения:

при <math>D_{ij} >0</math> : <math>w_{ij} = {{1}\over {{ (\sum_{k=1}^c {{D_{ij}}\over{D_{ik}}} ) }^{2/(m-1)}}}, j = 1,...,c</math>

при <math>D_{ij} =0</math> : <math>w_{ij} = \delta_{ij}, j = 1,...,c</math>, где <math>\delta_{ij}</math> - символ Кронекера

6) Если <math>|| F - F^{*} || < \varepsilon </math>, где <math>F^{*}</math> - матрица нечеткого разбиения предыдущей итерации, то идем далее, иначе возвращаемся на пункт 3.

7) Конец.

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

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

* Поиск <math>V_j</math> - расчет центроидов (пункт 3 алгоритма)
* Нахождение <math>D_{ij}</math> - расстояний между объектами (пункт 4 алгоритма)
* Пересчет <math>w_{ij}</math> - элементов матрицы разбиения (пункт 5 алгоритма)

== Макроструктура алгоритма ==
Основные шаги при реализации алгоритма
* Генерация случайной матрицы размера <math>M</math> на где <math>c</math>, проверка условий
* Расчет центроидов – по сути, скалярное произведение с нормировкой
* Расчет расстояний – в общепринятом случае является скалярным произведением
* Пересчет матрицы – по сути, скалярное произведение
* Проверка условий останова – вычисление нормы

== Схема реализации последовательного алгоритма ==
float ** FuzzyCMeans (float** X, c, m, eps){
n = X.size();
r = X[0].size();
centers = generateZeroFill(c, r)
Wprev = genetateRandFill(n, c);
W = Wprev;
while (true){
// обновляем центры кластеров
for (int i=0; i<c; i++){
float * num = new float []();
float den = 0;
for (int j=0; j<n; j++){
num += pow(W[j][i], m) * X[j];
den+=pow(W[j][i], m);
}
centers[i] = num / den;
}
//обновляем вероятности W и считаем расстояние между матрицами W и Wprev
float max_diff = 0;
for (int i=0; i<n; i++)
for (int j=0; j<c; j++){
total = 0;
for (int m=0; m<с; m++)
total += pow(distance(X[i], centers[j]) / distance(X[i], centers[m]), 2/(m-1));
W[i][j] = 1/total;
max_diff = max(abs(Wprev[i][j]-W[i][j]), max_diff);
Wprev[i][j] = W[i][j];
}
if (max_diff < eps):
break;
}
return W;
}

== Последовательная сложность алгоритма ==
Последовательная сложность алгоритма состоит из сложности каждой итерации умноженной на их количество. Так как число итераций заранее неизвестно и зависит от входных параметров, рассмотрим сложность на каждой итерации. Наибольшую сложность представляет собой пересчет матрицы, сложность которого <math>O(c^2 nd)</math> (по сравнению со сложностью <math>O(cnd)</math> расчета расстояний, вычисления центроидов и проверки условия останова). Итого общая сложность алгоритма <math>O(c^2 ndi)</math>

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

'''Первый ярус''' состоит из <math>M</math> параллельных операций 1, 2, совершаемых в цикле <math>c</math> раз для каждого кластера.

'''Операция 1''': <math>w_{ij}^m</math>, где <math>j</math> - номер итерации в цикле, <math>i</math> - номер параллельной ветви.

'''Операция 2''': <math>w_{ij}^m*X_i</math>

Здесь <math>j</math> - номер итерации в цикле, <math>i</math> - номер параллельной ветви.

На выходе из каждой ветки получаем вектор размера <math>1</math> x <math>c</math> и матрицу размера <math>d</math> x <math>c</math>.
Далее совершаем поэлементное сложение векторов и матриц соответственно, а затем делим каждый столбец в матрице на соответствующий элемент в векторе.

'''Второй ярус''' состоит их <math>M</math> параллельных операций 3, 4, 5 также совершаемых в цикле <math>c</math> раз.

'''Операция 4''': обновление значения <math>w_{ij}</math> по указанной в разделе 1.2 в пункте 5 формуле.

'''Операция 5''': <math>maximum = max(|w_{ij} - w_{ij}^{prev}|, maximum)</math>.

'''Операция 6''': <math>w_{ij}^{prev} = w_{ij}</math>.

Здесь <math>j</math> - номер итерации в цикле, <math>i</math> - номер параллельной ветви.

На выходе из каждой ветки получаем число <math>maximum</math>. Далее находим максимальное значение из полученных величин для каждой ветки. Затем проверяем условие останова алгоритма.

[[File:Scheme.JPG]]

== Ресурс параллелизма алгоритма ==
Параллельная сложность алгоритма: <math>M*c^2*i</math>. Такая сложность получается за счет распараллеливания на каждом ярусе <math>M</math> операций. Иерархическая структура параллелизма подробно описана в [[#Информационный граф|п.1.7]].

В алгоритме не возникает скошенного параллелизма.

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

* Входные данные алгоритма: набор векторов <math>x_i</math> размерности <math>d</math>, где <math>i = 1,...,M</math>; <math>M</math> - количество векторов.
* Объем входных данных: <math>M*d</math> , [количество наблюдений * размерность].
* Выходные данные алгоритма: матрица вероятностей принадлежности векторов кластерам <math>M</math> на <math>c</math>.
* Объем выходных данных: <math>M*c</math> , [количество наблюдений * количество кластеров].

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

* Соотношение последовательной и параллельной формы алгоритма: <math>M</math>
* Вычислительная мощность: <math>{dc^2i} \over {c+d}</math>.
* Устойчивость: алгоритм не является устойчивым, поэтому существует много исследований о том, как первоначально выбрать параметры кластеризации.
* Сбалансированность: в данном алгоритме операция умножения доминирует над операцией сложения. Операции между параллельными ветвями сбалансированны.
* Детерминированность: алгоритм не является детерминированным, так как матрица нечеткого разбиение генерируется произвольно.
* Степень исхода вершины информационного графа ( для одной интерации): 2 (3 - с учетом, если выходные данные пошли на следующую итерацию).

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

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

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

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

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

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

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

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

* Реализация алгоритма на POSTGRESQL: http://num-meth.srcc.msu.ru/zhurnal/tom_2012/pdf/v13r207.pdf
* Библиотека для MATLAB: http://www.mathworks.com/help/fuzzy/fcm.html (распространяется на коммерческой основе)

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

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

2016-10-28T16:27:42Z

Yushin:

{{algorithm
| name = Нечеткий алгоритм C средних
| serial_complexity = <math>O(Mdc^2i)</math>, <math>i</math> - количество итераций
| input_data = <math>M*d</math>, [количество наблюдений * размерность]
| output_data = <math>M*c</math>, [количество наблюдений * количество кластеров]
| pf_height = <math>2i</math>
| pf_width = <math>n</math>
}}

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

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

== Общее описание алгоритма ==
Кластеризация - это объединение объектов в группы (кластеры) на основе схожести признаков для объектов одной группы и отличий между группами. Нечеткий алгоритм C Средних (Fuzzy C-means, FCM) - алгоритм кластеризации, позволяющий объектам принадлежать с различной степенью нескольким кластерам одновременно. Впервые алгоритм был предложен J.C. Dunn в 1973 <ref>[http://www.tandfonline.com/doi/abs/10.1080/01969727308546046 | J. C. Dunn. A Fuzzy Relative of the ISODATA Process and Its Use in Detecting Compact Well-Separated Clusters. Journal of Cybernetics, volume 3,1973 - Issue 3, pp 32-57]</ref>. Нечеткое разбиение позволяет просто решить проблему объектов, расположенных на границе двух кластеров - им назначают степени принадлежностей равные 0.5.

Входные данные алгоритма: набор векторов, которые следует кластеризовать.

Параметры алгоритма: <math>c</math> - количество кластеров; <math>m</math> - экспоненциальный вес; <math>\varepsilon</math> - параметр останова алгоритма.

Выходные данные: матрица вероятностей принадлежности векторов кластерам.

Краткое описание алгоритма:

* Задать параметры алгоритма.

* Сгенерировать случайную матрицу принадлежностей векторов кластерам (матрицу нечеткого разбиения).

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

== Математическое описание алгоритма <ref>[http://it-claim.ru/Persons/Neyskiy/Article2_Neiskiy.pdf | Нейский И.М. Классификация и сравнение методов кластеризации.]</ref> ==

Пусть <math> W = w_{ij} \in[0,1],\; i = 1, ..., M, \; j = 1, ..., c</math> - матрица разбиения, где <math>w_{i,j}</math> - степень принадлежности объекта <math>i</math> к кластеру <math>j</math>; <math>c</math> - количество кластеров, <math>M</math> - количество векторов.

При этом элементы матрицы должны удовлетворять условиям:

* <math>\sum_{j = 1}^c w_{ij} = 1, i = 1, ..., M</math>                <math>(1)</math>
* <math>0 < \sum_{i = 1}^M w_{ij} < M, j = 1, ..., c</math>       <math>(2)</math>

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

1) Задаем параметры алгоритма: <math>c</math> - количество кластеров; <math>m >= 1</math> - экспоненциальный вес, определяющий нечеткость кластеров; <math>\varepsilon > 0</math> - параметр останова алгоритма.

2) Генерируем случайным образом матрицу нечеткого разбиения с учетом условий <math>(1)</math> и <math>(2)</math>

3) Рассчитываем центроиды (центры кластеров): <math>V_j = {{\sum_{i=1}^M w_{ij}^m * X_i} \over {\sum_{i=1}^M w_{ij}^m}}, j = 1, ..., c</math>

4) Рассчитываем расстояния между объектами <math>X</math> и центроидами:

<math>D_{ij} = {||X_i - V_j||}, i = 1,...,M; j = 1,...,c </math>

5) Пересчет элементов матрицы разбиения:

при <math>D_{ij} >0</math> : <math>w_{ij} = {{1}\over {{ (\sum_{k=1}^c {{D_{ij}}\over{D_{ik}}} ) }^{2/(m-1)}}}, j = 1,...,c</math>

при <math>D_{ij} =0</math> : <math>w_{ij} = \delta_{ij}, j = 1,...,c</math>, где <math>\delta_{ij}</math> - символ Кронекера

6) Если <math>|| F - F^{*} || < \varepsilon </math>, где <math>F^{*}</math> - матрица нечеткого разбиения предыдущей итерации, то идем далее, иначе возвращаемся на пункт 3.

7) Конец.

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

Вычислительным ядром алгоритма являются пункты (3), (4), (5) - расчет центроидов, вычисление расстояний и пересчет элементов матрицы соответственно

== Макроструктура алгоритма ==
Основные шаги при реализации алгоритма
* Генерация случайной матрицы размера <math>M</math> на где <math>c</math>, проверка условий
* Расчет центроидов – по сути, скалярное произведение с нормировкой
* Расчет расстояний – в общепринятом случае является скалярным произведением
* Пересчет матрицы – по сути, скалярное произведение
* Проверка условий останова – вычисление нормы

== Схема реализации последовательного алгоритма ==
float ** FuzzyCMeans (float** X, c, m, eps){
n = X.size();
r = X[0].size();
centers = generateZeroFill(c, r)
Wprev = genetateRandFill(n, c);
W = Wprev;
while (true){
// обновляем центры кластеров
for (int i=0; i<c; i++){
float * num = new float []();
float den = 0;
for (int j=0; j<n; j++){
num += pow(W[j][i], m) * X[j];
den+=pow(W[j][i], m);
}
centers[i] = num / den;
}
//обновляем вероятности W и считаем расстояние между матрицами W и Wprev
float max_diff = 0;
for (int i=0; i<n; i++)
for (int j=0; j<c; j++){
total = 0;
for (int m=0; m<с; m++)
total += pow(distance(X[i], centers[j]) / distance(X[i], centers[m]), 2/(m-1));
W[i][j] = 1/total;
max_diff = max(abs(Wprev[i][j]-W[i][j]), max_diff);
Wprev[i][j] = W[i][j];
}
if (max_diff < eps):
break;
}
return W;
}

== Последовательная сложность алгоритма ==
Последовательная сложность алгоритма состоит из сложности каждой итерации умноженной на их количество. Так как число итераций заранее неизвестно и зависит от входных параметров, рассмотрим сложность на каждой итерации. Наибольшую сложность представляет собой пересчет матрицы, сложность которого <math>O(c^2 nd)</math> (по сравнению со сложностью <math>O(cnd)</math> расчета расстояний, вычисления центроидов и проверки условия останова). Итого общая сложность алгоритма <math>O(c^2 ndi)</math>

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

'''Первый ярус''' состоит из <math>M</math> параллельных операций 1, 2, совершаемых в цикле <math>c</math> раз для каждого кластера.

'''Операция 1''': <math>w_{ij}^m</math>, где <math>j</math> - номер итерации в цикле, <math>i</math> - номер параллельной ветви.

'''Операция 2''': <math>w_{ij}^m*X_i</math>

Здесь <math>j</math> - номер итерации в цикле, <math>i</math> - номер параллельной ветви.

На выходе из каждой ветки получаем вектор размера <math>1</math> x <math>c</math> и матрицу размера <math>d</math> x <math>c</math>.
Далее совершаем поэлементное сложение векторов и матриц соответственно, а затем делим каждый столбец в матрице на соответствующий элемент в векторе.

'''Второй ярус''' состоит их <math>M</math> параллельных операций 3, 4, 5 также совершаемых в цикле <math>c</math> раз.

'''Операция 4''': обновление значения <math>w_{ij}</math> по указанной в разделе 1.2 в пункте 5 формуле.

'''Операция 5''': <math>maximum = max(|w_{ij} - w_{ij}^{prev}|, maximum)</math>.

'''Операция 6''': <math>w_{ij}^{prev} = w_{ij}</math>.

Здесь <math>j</math> - номер итерации в цикле, <math>i</math> - номер параллельной ветви.

На выходе из каждой ветки получаем число <math>maximum</math>. Далее находим максимальное значение из полученных величин для каждой ветки. Затем проверяем условие останова алгоритма.

[[File:Scheme.JPG]]

== Ресурс параллелизма алгоритма ==
Параллельная сложность алгоритма: <math>M*c^2*i</math>. Такая сложность получается за счет распараллеливания на каждом ярусе <math>M</math> операций. Иерархическая структура параллелизма подробно описана в [[#Информационный граф|п.1.7]].

В алгоритме не возникает скошенного параллелизма.

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

* Входные данные алгоритма: набор векторов <math>x_i</math> размерности <math>d</math>, где <math>i = 1,...,M</math>; <math>M</math> - количество векторов.
* Объем входных данных: <math>M*d</math> , [количество наблюдений * размерность].
* Выходные данные алгоритма: матрица вероятностей принадлежности векторов кластерам <math>M</math> на <math>c</math>.
* Объем выходных данных: <math>M*c</math> , [количество наблюдений * количество кластеров].

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

* Соотношение последовательной и параллельной формы алгоритма: <math>M</math>
* Вычислительная мощность: <math>{dc^2i} \over {c+d}</math>.
* Устойчивость: алгоритм не является устойчивым, поэтому существует много исследований о том, как первоначально выбрать параметры кластеризации.
* Сбалансированность: в данном алгоритме операция умножения доминирует над операцией сложения. Операции между параллельными ветвями сбалансированны.
* Детерминированность: алгоритм не является детерминированным, так как матрица нечеткого разбиение генерируется произвольно.
* Степень исхода вершины информационного графа ( для одной интерации): 2 (3 - с учетом, если выходные данные пошли на следующую итерацию).

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

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

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

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

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

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

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

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

* Реализация алгоритма на POSTGRESQL: http://num-meth.srcc.msu.ru/zhurnal/tom_2012/pdf/v13r207.pdf
* Библиотека для MATLAB: http://www.mathworks.com/help/fuzzy/fcm.html (распространяется на коммерческой основе)

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

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

2016-10-28T16:27:15Z

Yushin:

{{algorithm
| name = Нечеткий алгоритм C средних
| serial_complexity = <math>O(Mdc^2i)</math>, <math>i</math> - количество итераций
| input_data = <math>M*d</math>, [количество наблюдений * размерность]
| output_data = <math>M*c</math>, [количество наблюдений * количество кластеров]
| pf_height = <math>2i</math>
| pf_width = <math>n</math>
}}

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

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

== Общее описание алгоритма ==
Кластеризация - это объединение объектов в группы (кластеры) на основе схожести признаков для объектов одной группы и отличий между группами. Нечеткий алгоритм C Средних (Fuzzy C-means, FCM) - алгоритм кластеризации, позволяющий объектам принадлежать с различной степенью нескольким кластерам одновременно. Впервые алгоритм был предложен J.C. Dunn в 1973 <ref>[http://www.tandfonline.com/doi/abs/10.1080/01969727308546046 | J. C. Dunn. A Fuzzy Relative of the ISODATA Process and Its Use in Detecting Compact Well-Separated Clusters. Journal of Cybernetics, volume 3,1973 - Issue 3, pp 32-57]</ref>. Нечеткое разбиение позволяет просто решить проблему объектов, расположенных на границе двух кластеров - им назначают степени принадлежностей равные 0.5.

Входные данные алгоритма: набор векторов, которые следует кластеризовать.

Параметры алгоритма: <math>c</math> - количество кластеров; <math>m</math> - экспоненциальный вес; <math>\varepsilon</math> - параметр останова алгоритма.

Выходные данные: матрица вероятностей принадлежности векторов кластерам.

Краткое описание алгоритма:

* Задать параметры алгоритма.

* Сгенерировать случайную матрицу принадлежностей векторов кластерам (матрицу нечеткого разбиения).

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

== Математическое описание алгоритма <ref>[http://it-claim.ru/Persons/Neyskiy/Article2_Neiskiy.pdf | Нейский И.М. Классификация и сравнение методов кластеризации.]</ref> ==

Пусть <math> W = w_{ij} \in[0,1],\; i = 1, ..., M, \; j = 1, ..., c</math> - матрица разбиения, где <math>w_{i,j}</math> - степень принадлежности объекта <math>i</math> к кластеру <math>j</math>; <math>c</math> - количество кластеров, <math>M</math> - количество векторов.

При этом элементы матрицы должны удовлетворять условиям:

* <math>\sum_{j = 1}^c w_{ij} = 1, i = 1, ..., M</math>                <math>(1)</math>
* <math>0 < \sum_{i = 1}^M w_{ij} < M, j = 1, ..., c</math>       <math>(2)</math>

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

1) Задаем параметры алгоритма: <math>c</math> - количество кластеров; <math>m >= 1</math> - экспоненциальный вес, определяющий нечеткость кластеров; <math>\varepsilon > 0</math> - параметр останова алгоритма.

2) Генерируем случайным образом матрицу нечеткого разбиения с учетом условий <math>(1)</math> и <math>(2)</math>

3) Рассчитываем центроиды (центры кластеров): <math>V_j = {{\sum_{i=1}^M w_{ij}^m * X_i} \over {\sum_{i=1}^M w_{ij}^m}}, j = 1, ..., c</math>

4) Рассчитываем расстояния между объектами <math>X</math> и центроидами:

<math>D_{ij} = {||X_i - V_j||}, i = 1,...,M; j = 1,...,c </math>

5) Пересчет элементов матрицы разбиения:

при <math>D_{ij} >0</math> : <math>w_{ij} = {{1}\over {{ (\sum_{k=1}^c {{D_{ij}}\over{D_{ik}}} ) }^{2/(m-1)}}}, j = 1,...,c</math>

при <math>D_{ij} =0</math> : <math>w_{ij} = \delta_{ij}, j = 1,...,c</math>, где <math>\delta_{ij}</math> - символ Кронекера

6) Если <math>|| F - F^{*} || < \varepsilon </math>, где <math>F^{*}</math> - матрица нечеткого разбиения предыдущей итерации, то идем далее, иначе возвращаемся на пункт 3.

7) Конец.

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

Вычислительным ядром алгоритма являются пункты (3), (4), (5) - расчет центроидов, вычисление расстояний и пересчет элементов матрицы соответственно

== Макроструктура алгоритма ==
Основные шаги при реализации алгоритма
* Генерация случайной матрицы размера <math>M</math> на где <math>c</math>, проверка условий
* Расчет центроидов – по сути, скалярное произведение с нормировкой
* Расчет расстояний – в общепринятом случае является скалярным произведением
* Пересчет матрицы – по сути, скалярное произведение
* Проверка условий останова – вычисление нормы

== Схема реализации последовательного алгоритма ==
float ** FuzzyCMeans (float** X, c, m, eps){
n = X.size();
r = X[0].size();
centers = generateZeroFill(c, r)
Wprev = genetateRandFill(n, c);
W = Wprev;
while (true){
// обновляем центры кластеров
for (int i=0; i<c; i++){
float * num = new float []();
float den = 0;
for (int j=0; j<n; j++){
num += pow(W[j][i], m) * X[j];
den+=pow(W[j][i], m);
}
centers[i] = num / den;
}
//обновляем вероятности W и считаем расстояние между матрицами W и Wprev
float max_diff = 0;
for (int i=0; i<n; i++)
for (int j=0; j<c; j++){
total = 0;
for (int m=0; m<с; m++)
total += pow(distance(X[i], centers[j]) / distance(X[i], centers[m]), 2/(m-1));
W[i][j] = 1/total;
max_diff = max(abs(Wprev[i][j]-W[i][j]), max_diff);
Wprev[i][j] = W[i][j];
}
if (max_diff < eps):
break;
}
return W;
}

== Последовательная сложность алгоритма ==
Последовательная сложность алгоритма состоит из сложности каждой итерации умноженной на их количество. Так как число итераций заранее неизвестно и зависит от входных параметров, рассмотрим сложность на каждой итерации. Наибольшую сложность представляет собой пересчет матрицы, сложность которого <math>O(c^2 nd)</math> (по сравнению со сложностью <math>O(cnd)</math> расчета расстояний, вычисления центроидов и проверки условия останова). Итого общая сложность алгоритма <math>O(c^2 ndi)</math>

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

'''Первый ярус''' состоит из <math>M</math> параллельных операций 1, 2, совершаемых в цикле <math>c</math> раз для каждого кластера.

'''Операция 1''': <math>w_{ij}^m</math>, где <math>j</math> - номер итерации в цикле, <math>i</math> - номер параллельной ветви.

'''Операция 2''': <math>w_{ij}^m*X_i</math>

Здесь <math>j</math> - номер итерации в цикле, <math>i</math> - номер параллельной ветви.

На выходе из каждой ветки получаем вектор размера <math>1</math> x <math>c</math> и матрицу размера <math>d</math> x <math>c</math>.
Далее совершаем поэлементное сложение векторов и матриц соответственно, а затем делим каждый столбец в матрице на соответствующий элемент в векторе.

'''Второй ярус''' состоит их <math>M</math> параллельных операций 3, 4, 5 также совершаемых в цикле <math>c</math> раз.

'''Операция 4''': обновление значения <math>w_{ij}</math> по указанной в разделе 1.2 в пункте 5 формуле.

'''Операция 5''': <math>maximum = max(|w_{ij} - w_{ij}^{prev}|, maximum)</math>.

'''Операция 6''': <math>w_{ij}^{prev} = w_{ij}</math>.

Здесь <math>j</math> - номер итерации в цикле, <math>i</math> - номер параллельной ветви.

На выходе из каждой ветки получаем число <math>maximum</math>. Далее находим максимальное значение из полученных величин для каждой ветки. Затем проверяем условие останова алгоритма.

[[File:Scheme.JPG]]

== Ресурс параллелизма алгоритма ==
Параллельная сложность алгоритма: <math>M*c^2*i</math>. Такая сложность получается за счет распараллеливания на каждом ярусе <math>M</math> операций. Иерархическая структура параллелизма подробно описана в [[#Информационный граф|п.1.7]].

В алгоритме не возникает скошенного параллелизма.

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

* Входные данные алгоритма: набор векторов <math>x_i</math> размерности <math>d</math>, где <math>i = 1,...,M</math>; <math>M</math> - количество векторов.
* Объем входных данных: <math>M*d</math>, [количество наблюдений * размерность].
* Выходные данные алгоритма: матрица вероятностей принадлежности векторов кластерам <math>M</math> на <math>c</math>.
* Объем выходных данных: <math>M*c</math>, [количество наблюдений * количество кластеров].

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

* Соотношение последовательной и параллельной формы алгоритма: <math>M</math>
* Вычислительная мощность: <math>{dc^2i} \over {c+d}</math>.
* Устойчивость: алгоритм не является устойчивым, поэтому существует много исследований о том, как первоначально выбрать параметры кластеризации.
* Сбалансированность: в данном алгоритме операция умножения доминирует над операцией сложения. Операции между параллельными ветвями сбалансированны.
* Детерминированность: алгоритм не является детерминированным, так как матрица нечеткого разбиение генерируется произвольно.
* Степень исхода вершины информационного графа ( для одной интерации): 2 (3 - с учетом, если выходные данные пошли на следующую итерацию).

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

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

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

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

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

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

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

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

* Реализация алгоритма на POSTGRESQL: http://num-meth.srcc.msu.ru/zhurnal/tom_2012/pdf/v13r207.pdf
* Библиотека для MATLAB: http://www.mathworks.com/help/fuzzy/fcm.html (распространяется на коммерческой основе)

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

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

2016-10-28T16:25:20Z

Yushin:

{{algorithm
| name = Нечеткий алгоритм C средних
| serial_complexity = <math>O(Mdc^2i)</math>, <math>i</math> - количество итераций
| input_data = <math>M*d</math>, [количество наблюдений * размерность]
| output_data = <math>M*c</math>, [количество наблюдений * количество кластеров]
| pf_height = <math>2i</math>
| pf_width = <math>n</math>
}}

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

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

== Общее описание алгоритма ==
Кластеризация - это объединение объектов в группы (кластеры) на основе схожести признаков для объектов одной группы и отличий между группами. Нечеткий алгоритм C Средних (Fuzzy C-means, FCM) - алгоритм кластеризации, позволяющий объектам принадлежать с различной степенью нескольким кластерам одновременно. Впервые алгоритм был предложен J.C. Dunn в 1973 <ref>[http://www.tandfonline.com/doi/abs/10.1080/01969727308546046 | J. C. Dunn. A Fuzzy Relative of the ISODATA Process and Its Use in Detecting Compact Well-Separated Clusters. Journal of Cybernetics, volume 3,1973 - Issue 3, pp 32-57]</ref>. Нечеткое разбиение позволяет просто решить проблему объектов, расположенных на границе двух кластеров - им назначают степени принадлежностей равные 0.5.

Входные данные алгоритма: набор векторов, которые следует кластеризовать.

Параметры алгоритма: <math>c</math> - количество кластеров; <math>m</math> - экспоненциальный вес; <math>\varepsilon</math> - параметр останова алгоритма.

Выходные данные: матрица вероятностей принадлежности векторов кластерам.

Краткое описание алгоритма:

* Задать параметры алгоритма.

* Сгенерировать случайную матрицу принадлежностей векторов кластерам (матрицу нечеткого разбиения).

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

== Математическое описание алгоритма <ref>[http://it-claim.ru/Persons/Neyskiy/Article2_Neiskiy.pdf | Нейский И.М. Классификация и сравнение методов кластеризации.]</ref> ==

Пусть <math> W = w_{ij} \in[0,1],\; i = 1, ..., M, \; j = 1, ..., c</math> - матрица разбиения, где <math>w_{i,j}</math> - степень принадлежности объекта <math>i</math> к кластеру <math>j</math>; <math>c</math> - количество кластеров, <math>M</math> - количество векторов.

При этом элементы матрицы должны удовлетворять условиям:

* <math>\sum_{j = 1}^c w_{ij} = 1, i = 1, ..., M</math>                <math>(1)</math>
* <math>0 < \sum_{i = 1}^M w_{ij} < M, j = 1, ..., c</math>       <math>(2)</math>

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

1) Задаем параметры алгоритма: <math>c</math> - количество кластеров; <math>m >= 1</math> - экспоненциальный вес, определяющий нечеткость кластеров; <math>\varepsilon > 0</math> - параметр останова алгоритма.

2) Генерируем случайным образом матрицу нечеткого разбиения с учетом условий <math>(1)</math> и <math>(2)</math>

3) Рассчитываем центроиды (центры кластеров): <math>V_j = {{\sum_{i=1}^M w_{ij}^m * X_i} \over {\sum_{i=1}^M w_{ij}^m}}, j = 1, ..., c</math>

4) Рассчитываем расстояния между объектами <math>X</math> и центроидами:

<math>D_{ij} = {||X_i - V_j||}, i = 1,...,M; j = 1,...,c </math>

5) Пересчет элементов матрицы разбиения:

при <math>D_{ij} >0</math> : <math>w_{ij} = {{1}\over {{ (\sum_{k=1}^c {{D_{ij}}\over{D_{ik}}} ) }^{2/(m-1)}}}, j = 1,...,c</math>

при <math>D_{ij} =0</math> : <math>w_{ij} = \delta_{ij}, j = 1,...,c</math>, где <math>\delta_{ij}</math> - символ Кронекера

6) Если <math>|| F - F^{*} || < \varepsilon </math>, где <math>F^{*}</math> - матрица нечеткого разбиения предыдущей итерации, то идем далее, иначе возвращаемся на пункт 3.

7) Конец.

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

Вычислительным ядром алгоритма являются пункты (3), (4), (5) - расчет центроидов, вычисление расстояний и пересчет элементов матрицы соответственно

== Макроструктура алгоритма ==
Основные шаги при реализации алгоритма
* Генерация случайной матрицы размера <math>M</math> на где <math>c</math>, проверка условий
* Расчет центроидов – по сути, скалярное произведение с нормировкой
* Расчет расстояний – в общепринятом случае является скалярным произведением
* Пересчет матрицы – по сути, скалярное произведение
* Проверка условий останова – вычисление нормы

== Схема реализации последовательного алгоритма ==
float ** FuzzyCMeans (float** X, c, m, eps){
n = X.size();
r = X[0].size();
centers = generateZeroFill(c, r)
Wprev = genetateRandFill(n, c);
W = Wprev;
while (true){
// обновляем центры кластеров
for (int i=0; i<c; i++){
float * num = new float []();
float den = 0;
for (int j=0; j<n; j++){
num += pow(W[j][i], m) * X[j];
den+=pow(W[j][i], m);
}
centers[i] = num / den;
}
//обновляем вероятности W и считаем расстояние между матрицами W и Wprev
float max_diff = 0;
for (int i=0; i<n; i++)
for (int j=0; j<c; j++){
total = 0;
for (int m=0; m<с; m++)
total += pow(distance(X[i], centers[j]) / distance(X[i], centers[m]), 2/(m-1));
W[i][j] = 1/total;
max_diff = max(abs(Wprev[i][j]-W[i][j]), max_diff);
Wprev[i][j] = W[i][j];
}
if (max_diff < eps):
break;
}
return W;
}

== Последовательная сложность алгоритма ==
Последовательная сложность алгоритма состоит из сложности каждой итерации умноженной на их количество. Так как число итераций заранее неизвестно и зависит от входных параметров, рассмотрим сложность на каждой итерации. Наибольшую сложность представляет собой пересчет матрицы, сложность которого <math>O(c^2 nd)</math> (по сравнению со сложностью <math>O(cnd)</math> расчета расстояний, вычисления центроидов и проверки условия останова). Итого общая сложность алгоритма <math>O(c^2 ndi)</math>

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

'''Первый ярус''' состоит из <math>M</math> параллельных операций 1, 2, совершаемых в цикле <math>c</math> раз для каждого кластера.

'''Операция 1''': <math>w_{ij}^m</math>, где <math>j</math> - номер итерации в цикле, <math>i</math> - номер параллельной ветви.

'''Операция 2''': <math>w_{ij}^m*X_i</math>

Здесь <math>j</math> - номер итерации в цикле, <math>i</math> - номер параллельной ветви.

На выходе из каждой ветки получаем вектор размера <math>1</math> x <math>c</math> и матрицу размера <math>d</math> x <math>c</math>.
Далее совершаем поэлементное сложение векторов и матриц соответственно, а затем делим каждый столбец в матрице на соответствующий элемент в векторе.

'''Второй ярус''' состоит их <math>M</math> параллельных операций 3, 4, 5 также совершаемых в цикле <math>c</math> раз.

'''Операция 4''': обновление значения <math>w_{ij}</math> по указанной в разделе 1.2 в пункте 5 формуле.

'''Операция 5''': <math>maximum = max(|w_{ij} - w_{ij}^{prev}|, maximum)</math>.

'''Операция 6''': <math>w_{ij}^{prev} = w_{ij}</math>.

Здесь <math>j</math> - номер итерации в цикле, <math>i</math> - номер параллельной ветви.

На выходе из каждой ветки получаем число <math>maximum</math>. Далее находим максимальное значение из полученных величин для каждой ветки. Затем проверяем условие останова алгоритма.

[[File:Scheme.JPG]]

== Ресурс параллелизма алгоритма ==
Параллельная сложность алгоритма: <math>M*c^2*i</math>. Такая сложность получается за счет распараллеливания на каждом ярусе <math>M</math> операций. Иерархическая структура параллелизма подробно описана в [[#Информационный граф|п.1.7]].

В алгоритме не возникает скошенного параллелизма.

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

* Входные данные алгоритма: набор векторов <math>x_i</math> размерности <math>d</math>, где <math>i = 1,...,M</math>; <math>M</math> - количество векторов.
* Выходные данные алгоритма: матрица вероятностей принадлежности векторов кластерам <math>M</math> на <math>c</math>.

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

* Соотношение последовательной и параллельной формы алгоритма: <math>M</math>
* Вычислительная мощность: <math>{dc^2i} \over {c+d}</math>.
* Устойчивость: алгоритм не является устойчивым, поэтому существует много исследований о том, как первоначально выбрать параметры кластеризации.
* Сбалансированность: в данном алгоритме операция умножения доминирует над операцией сложения. Операции между параллельными ветвями сбалансированны.
* Детерминированность: алгоритм не является детерминированным, так как матрица нечеткого разбиение генерируется произвольно.
* Степень исхода вершины информационного графа ( для одной интерации): 2 (3 - с учетом, если выходные данные пошли на следующую итерацию).

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

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

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

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

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

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

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

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

* Реализация алгоритма на POSTGRESQL: http://num-meth.srcc.msu.ru/zhurnal/tom_2012/pdf/v13r207.pdf
* Библиотека для MATLAB: http://www.mathworks.com/help/fuzzy/fcm.html (распространяется на коммерческой основе)

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

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

2016-10-28T16:13:48Z

Yushin:

{{algorithm
| name = Нечеткий алгоритм C средних
| serial_complexity = <math>O(Mdc^2i)</math>, <math>i</math> - количество итераций
| input_data = <math>M*d</math>, [количество наблюдений * размерность]
| output_data = <math>M*c</math>, [количество наблюдений * количество кластеров]
| pf_height = <math>2i</math>
| pf_width = <math>n</math>
}}

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

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

== Общее описание алгоритма ==
Кластеризация - это объединение объектов в группы (кластеры) на основе схожести признаков для объектов одной группы и отличий между группами. Нечеткий алгоритм C Средних (Fuzzy C-means, FCM) - алгоритм кластеризации, позволяющий объектам принадлежать с различной степенью нескольким кластерам одновременно. Впервые алгоритм был предложен J.C. Dunn в 1973 <ref>{{Cite journal|last=Dunn|first=J. C.|date=1973-01-01|title=A Fuzzy Relative of the ISODATA Process and Its Use in Detecting Compact Well-Separated Clusters|url=http://dx.doi.org/10.1080/01969727308546046|journal=Journal of Cybernetics|volume=3|issue=3|pages=32–57|doi=10.1080/01969727308546046|issn=0022-0280}}</ref>. Нечеткое разбиение позволяет просто решить проблему объектов, расположенных на границе двух кластеров - им назначают степени принадлежностей равные 0.5.

Входные данные алгоритма: набор векторов, которые следует кластеризовать.

Параметры алгоритма: <math>c</math> - количество кластеров; <math>m</math> - экспоненциальный вес; <math>\varepsilon</math> - параметр останова алгоритма.

Выходные данные: матрица вероятностей принадлежности векторов кластерам.

Краткое описание алгоритма:

* Задать параметры алгоритма.

* Сгенерировать случайную матрицу принадлежностей векторов кластерам (матрицу нечеткого разбиения).

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

== Математическое описание алгоритма <ref>http://it-claim.ru/Persons/Neyskiy/Article2_Neiskiy.pdf</ref> ==

Пусть <math> W = w_{ij} \in[0,1],\; i = 1, ..., M, \; j = 1, ..., c</math> - матрица разбиения, где <math>w_{i,j}</math> - степень принадлежности объекта <math>i</math> к кластеру <math>j</math>; <math>c</math> - количество кластеров, <math>M</math> - количество векторов.

При этом элементы матрицы должны удовлетворять условиям:

* <math>\sum_{j = 1}^c w_{ij} = 1, i = 1, ..., M</math>                <math>(1)</math>
* <math>0 < \sum_{i = 1}^M w_{ij} < M, j = 1, ..., c</math>       <math>(2)</math>

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

1) Задаем параметры алгоритма: <math>c</math> - количество кластеров; <math>m >= 1</math> - экспоненциальный вес, определяющий нечеткость кластеров; <math>\varepsilon > 0</math> - параметр останова алгоритма.

2) Генерируем случайным образом матрицу нечеткого разбиения с учетом условий <math>(1)</math> и <math>(2)</math>

3) Рассчитываем центроиды (центры кластеров): <math>V_j = {{\sum_{i=1}^M w_{ij}^m * X_i} \over {\sum_{i=1}^M w_{ij}^m}}, j = 1, ..., c</math>

4) Рассчитываем расстояния между объектами <math>X</math> и центроидами:

<math>D_{ij} = {||X_i - V_j||}, i = 1,...,M; j = 1,...,c </math>

5) Пересчет элементов матрицы разбиения:

при <math>D_{ij} >0</math> : <math>w_{ij} = {{1}\over {{ (\sum_{k=1}^c {{D_{ij}}\over{D_{ik}}} ) }^{2/(m-1)}}}, j = 1,...,c</math>

при <math>D_{ij} =0</math> : <math>w_{ij} = \delta_{ij}, j = 1,...,c</math>, где <math>\delta_{ij}</math> - символ Кронекера

6) Если <math>|| F - F^{*} || < \varepsilon </math>, где <math>F^{*}</math> - матрица нечеткого разбиения предыдущей итерации, то идем далее, иначе возвращаемся на пункт 3.

7) Конец.

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

Вычислительным ядром алгоритма являются пункты (3), (4), (5) - расчет центроидов, вычисление расстояний и пересчет элементов матрицы соответственно

== Макроструктура алгоритма ==
Основные шаги при реализации алгоритма
* Генерация случайной матрицы размера <math>M</math> на где <math>c</math>, проверка условий
* Расчет центроидов – по сути, скалярное произведение с нормировкой
* Расчет расстояний – в общепринятом случае является скалярным произведением
* Пересчет матрицы – по сути, скалярное произведение
* Проверка условий останова – вычисление нормы

== Схема реализации последовательного алгоритма ==
float ** FuzzyCMeans (float** X, c, m, eps){
n = X.size();
r = X[0].size();
centers = generateZeroFill(c, r)
Wprev = genetateRandFill(n, c);
W = Wprev;
while (true){
// обновляем центры кластеров
for (int i=0; i<c; i++){
float * num = new float []();
float den = 0;
for (int j=0; j<n; j++){
num += pow(W[j][i], m) * X[j];
den+=pow(W[j][i], m);
}
centers[i] = num / den;
}
//обновляем вероятности W и считаем расстояние между матрицами W и Wprev
float max_diff = 0;
for (int i=0; i<n; i++)
for (int j=0; j<c; j++){
total = 0;
for (int m=0; m<с; m++)
total += pow(distance(X[i], centers[j]) / distance(X[i], centers[m]), 2/(m-1));
W[i][j] = 1/total;
max_diff = max(abs(Wprev[i][j]-W[i][j]), max_diff);
Wprev[i][j] = W[i][j];
}
if (max_diff < eps):
break;
}
return W;
}

== Последовательная сложность алгоритма ==
Последовательная сложность алгоритма состоит из сложности каждой итерации умноженной на их количество. Так как число итераций заранее неизвестно и зависит от входных параметров, рассмотрим сложность на каждой итерации. Наибольшую сложность представляет собой пересчет матрицы, сложность которого <math>O(c^2 nd)</math> (по сравнению со сложностью <math>O(cnd)</math> расчета расстояний, вычисления центроидов и проверки условия останова). Итого общая сложность алгоритма <math>O(c^2 ndi)</math>

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

'''Первый ярус''' состоит из <math>M</math> параллельных операций 1, 2, совершаемых в цикле <math>c</math> раз для каждого кластера.

'''Операция 1''': <math>w_{ij}^m</math>, где <math>j</math> - номер итерации в цикле, <math>i</math> - номер параллельной ветви.

'''Операция 2''': <math>w_{ij}^m*X_i</math>

Здесь <math>j</math> - номер итерации в цикле, <math>i</math> - номер параллельной ветви.

На выходе из каждой ветки получаем вектор размера <math>1</math> x <math>c</math> и матрицу размера <math>d</math> x <math>c</math>.
Далее совершаем поэлементное сложение векторов и матриц соответственно, а затем делим каждый столбец в матрице на соответствующий элемент в векторе.

'''Второй ярус''' состоит их <math>M</math> параллельных операций 3, 4, 5 также совершаемых в цикле <math>c</math> раз.

'''Операция 4''': обновление значения <math>w_{ij}</math> по указанной в разделе 1.2 в пункте 5 формуле.

'''Операция 5''': <math>maximum = max(|w_{ij} - w_{ij}^{prev}|, maximum)</math>.

'''Операция 6''': <math>w_{ij}^{prev} = w_{ij}</math>.

Здесь <math>j</math> - номер итерации в цикле, <math>i</math> - номер параллельной ветви.

На выходе из каждой ветки получаем число <math>maximum</math>. Далее находим максимальное значение из полученных величин для каждой ветки. Затем проверяем условие останова алгоритма.

[[File:Scheme.JPG]]

== Ресурс параллелизма алгоритма ==
Параллельная сложность алгоритма: <math>M*c^2*i</math>. Такая сложность получается за счет распараллеливания на каждом ярусе <math>M</math> операций. Иерархическая структура параллелизма подробно описана в [[#Информационный граф|п.1.7]].

В алгоритме не возникает скошенного параллелизма.

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

* Входные данные алгоритма: набор векторов <math>x_i</math> размерности <math>d</math>, где <math>i = 1,...,M</math>; <math>M</math> - количество векторов.
* Выходные данные алгоритма: матрица вероятностей принадлежности векторов кластерам <math>M</math> на <math>c</math>.

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

* Соотношение последовательной и параллельной формы алгоритма: <math>M</math>
* Вычислительная мощность: <math>{dc^2i} \over {c+d}</math>.
* Устойчивость: алгоритм не является устойчивым, поэтому существует много исследований о том, как первоначально выбрать параметры кластеризации.
* Сбалансированность: в данном алгоритме операция умножения доминирует над операцией сложения. Операции между параллельными ветвями сбалансированны.
* Детерминированность: алгоритм не является детерминированным, так как матрица нечеткого разбиение генерируется произвольно.
* Степень исхода вершины информационного графа ( для одной интерации): 2 (3 - с учетом, если выходные данные пошли на следующую итерацию).

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

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

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

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

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

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

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

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

* Реализация алгоритма на POSTGRESQL: http://num-meth.srcc.msu.ru/zhurnal/tom_2012/pdf/v13r207.pdf
* Библиотека для MATLAB: http://www.mathworks.com/help/fuzzy/fcm.html (распространяется на коммерческой основе)

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

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

2016-10-28T16:12:23Z

Yushin:

{{algorithm
| name = Нечеткий алгоритм C средних
| serial_complexity = <math>O(Mdc^2i)</math>, <math>i</math> - количество итераций
| input_data = <math>M*d</math>, [количество наблюдений * размерность]
| output_data = <math>M*c</math>, [количество наблюдений * количество кластеров]
| pf_height = <math>2i</math>
| pf_width = <math>n</math>
}}

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

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

== Общее описание алгоритма ==
Кластеризация - это объединение объектов в группы (кластеры) на основе схожести признаков для объектов одной группы и отличий между группами. Нечеткий алгоритм C Средних (Fuzzy C-means, FCM) - алгоритм кластеризации, позволяющий объектам принадлежать с различной степенью нескольким кластерам одновременно. Впервые алгоритм был предложен J.C. Dunn в 1973 <ref>{{Cite journal|last=Dunn|first=J. C.|date=1973-01-01|title=A Fuzzy Relative of the ISODATA Process and Its Use in Detecting Compact Well-Separated Clusters|url=http://dx.doi.org/10.1080/01969727308546046|journal=Journal of Cybernetics|volume=3|issue=3|pages=32–57|doi=10.1080/01969727308546046|issn=0022-0280}}</ref>. Нечеткое разбиение позволяет просто решить проблему объектов, расположенных на границе двух кластеров - им назначают степени принадлежностей равные 0.5.

Входные данные алгоритма: набор векторов, которые следует кластеризовать.

Параметры алгоритма: <math>c</math> - количество кластеров; <math>m</math> - экспоненциальный вес; <math>\varepsilon</math> - параметр останова алгоритма.

Выходные данные: матрица вероятностей принадлежности векторов кластерам.

Краткое описание алгоритма:

* Задать параметры алгоритма.

* Сгенерировать случайную матрицу принадлежностей векторов кластерам (матрицу нечеткого разбиения).

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

== Математическое описание алгоритма <ref>http://it-claim.ru/Persons/Neyskiy/Article2_Neiskiy.pdf</ref> ==

Пусть <math> W = w_{ij} \in[0,1],\; i = 1, ..., M, \; j = 1, ..., c</math> - матрица разбиения, где <math>w_{i,j}</math> - степень принадлежности объекта <math>i</math> к кластеру <math>j</math>; <math>c</math> - количество кластеров, <math>M</math> - количество векторов.

При этом элементы матрицы должны удовлетворять условиям:

* <math>\sum_{j = 1}^c w_{ij} = 1, i = 1, ..., M</math>                <math>(1)</math>
* <math>0 < \sum_{i = 1}^M w_{ij} < M, j = 1, ..., c</math>       <math>(2)</math>

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

1) Задаем параметры алгоритма: <math>c</math> - количество кластеров; <math>m >= 1</math> - экспоненциальный вес, определяющий нечеткость кластеров; <math>\varepsilon > 0</math> - параметр останова алгоритма.

2) Генерируем случайным образом матрицу нечеткого разбиения с учетом условий <math>(1)</math> и <math>(2)</math>

3) Рассчитываем центроиды (центры кластеров): <math>V_j = {{\sum_{i=1}^M w_{ij}^m * X_i} \over {\sum_{i=1}^M w_{ij}^m}}, j = 1, ..., c</math>

4) Рассчитываем расстояния между объектами <math>X</math> и центроидами:

<math>D_{ij} = {||X_i - V_j||}, i = 1,...,M; j = 1,...,c </math>

5) Пересчет элементов матрицы разбиения:

при <math>D_{ij} >0</math> : <math>w_{ij} = {{1}\over {{ (\sum_{k=1}^c {{D_{ij}}\over{D_{ik}}} ) }^{2/(m-1)}}}, j = 1,...,c</math>

при <math>D_{ij} =0</math> : <math>w_{ij} = \delta_{ij}, j = 1,...,c</math>, где <math>\delta_{ij}</math> - символ Кронекера

6) Если <math>|| F - F^{*} || < \varepsilon </math>, где <math>F^{*}</math> - матрица нечеткого разбиения предыдущей итерации, то идем далее, иначе возвращаемся на пункт 3.

7) Конец.

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

Вычислительным ядром алгоритма являются пункты (3), (4), (5) - расчет центроидов, вычисление расстояний и пересчет элементов матрицы соответственно

== Макроструктура алгоритма ==
Основные шаги при реализации алгоритма
* Генерация случайной матрицы размера <math>M</math> на где <math>c</math>, проверка условий
* Расчет центроидов – по сути, скалярное произведение с нормировкой
* Расчет расстояний – в общепринятом случае является скалярным произведением
* Пересчет матрицы – по сути, скалярное произведение
* Проверка условий останова – вычисление нормы

== Схема реализации последовательного алгоритма ==
float ** FuzzyCMeans (float** X, c, m, eps){
n = X.size();
r = X[0].size();
centers = generateZeroFill(c, r)
Wprev = genetateRandFill(n, c);
W = Wprev;
while (true){
// обновляем центры кластеров
for (int i=0; i<c; i++){
float * num = new float []();
float den = 0;
for (int j=0; j<n; j++){
num += pow(W[j][i], m) * X[j];
den+=pow(W[j][i], m);
}
centers[i] = num / den;
}
//обновляем вероятности W и считаем расстояние между матрицами W и Wprev
float max_diff = 0;
for (int i=0; i<n; i++)
for (int j=0; j<c; j++){
total = 0;
for (int m=0; m<с; m++)
total += pow(distance(X[i], centers[j]) / distance(X[i], centers[m]), 2/(m-1));
W[i][j] = 1/total;
max_diff = max(abs(Wprev[i][j]-W[i][j]), max_diff);
Wprev[i][j] = W[i][j];
}
if (max_diff < eps):
break;
}
return W;
}

== Последовательная сложность алгоритма ==
Последовательная сложность алгоритма состоит из сложности каждой итерации умноженной на их количество. Так как число итераций заранее неизвестно и зависит от входных параметров, рассмотрим сложность на каждой итерации. Наибольшую сложность представляет собой пересчет матрицы, сложность которого <math>O(c^2 nd)</math> (по сравнению со сложностью <math>O(cnd)</math> расчета расстояний, вычисления центроидов и проверки условия останова). Итого общая сложность алгоритма <math>O(c^2 ndi)</math>

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

'''Первый ярус''' состоит из <math>M</math> параллельных операций 1, 2, совершаемых в цикле <math>c</math> раз для каждого кластера.

'''Операция 1''': <math>w_{ij}^m</math>, где <math>j</math> - номер итерации в цикле, <math>i</math> - номер параллельной ветви.

'''Операция 2''': <math>w_{ij}^m*X_i</math>

Здесь <math>j</math> - номер итерации в цикле, <math>i</math> - номер параллельной ветви.

На выходе из каждой ветки получаем вектор размера <math>1</math> x <math>c</math> и матрицу размера <math>d</math> x <math>c</math>.
Далее совершаем поэлементное сложение векторов и матриц соответственно, а затем делим каждый столбец в матрице на соответствующий элемент в векторе.

'''Второй ярус''' состоит их <math>M</math> параллельных операций 3, 4, 5 также совершаемых в цикле <math>c</math> раз.

'''Операция 4''': обновление значения <math>w_{ij}</math> по указанной в разделе 1.2 в пункте 5 формуле.

'''Операция 5''': <math>maximum = max(|w_{ij} - w_{ij}^{prev}|, maximum)</math>.

'''Операция 6''': <math>w_{ij}^{prev} = w_{ij}</math>.

Здесь <math>j</math> - номер итерации в цикле, <math>i</math> - номер параллельной ветви.

На выходе из каждой ветки получаем число <math>maximum</math>. Далее находим максимальное значение из полученных величин для каждой ветки. Затем проверяем условие останова алгоритма.

[[File:Scheme.JPG]]

== Ресурс параллелизма алгоритма ==
Параллельная сложность алгоритма: <math>M*c^2*i</math>. Такая сложность получается за счет распараллеливания на каждом ярусе <math>M</math> операций. Иерархическая структура параллелизма подробно описана в [[#Информационный граф|п.1.7]].

В алгоритме не возникает скошенного параллелизма.

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

* Входные данные алгоритма: набор векторов <math>x_i</math> размерности <math>d</math>, где <math>i = 1,...,M</math>; <math>M</math> - количество векторов.
* Выходные данные алгоритма: матрица вероятностей принадлежности векторов кластерам <math>M</math> на <math>c</math>.

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

* Соотношение последовательной и параллельной формы алгоритма: <math>M</math>
* Вычислительная мощность: <math>{dc^2i} \over {c+d}</math>.
* Устойчивость: алгоритм не является устойчивым, поэтому существует много исследований о том, как первоначально выбрать параметры кластеризации.
* Сбалансированность: в данном алгоритме операция умножения доминирует над операцией сложения. Операции между параллельными ветвями сбалансированны.
* Детерминированность: алгоритм не является детерминированным, так как матрица нечеткого разбиение генерируется произвольно.
* Степень исхода вершины информационного графа ( для одной интерации): 2 (3 - с учетом, если выходные данные пошли на следующую итерацию).

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

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

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

* Реализация алгоритма на POSTGRESQL: http://num-meth.srcc.msu.ru/zhurnal/tom_2012/pdf/v13r207.pdf
* Библиотека для MATLAB: http://www.mathworks.com/help/fuzzy/fcm.html (распространяется на коммерческой основе)

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

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

2016-10-28T16:09:20Z

Yushin:

{{algorithm
| name = Нечеткий алгоритм C средних
| serial_complexity = <math>O(Mdc^2i)</math>, <math>i</math> - количество итераций
| input_data = <math>M*d</math>, [количество наблюдений * размерность]
| output_data = <math>M*c</math>, [количество наблюдений * количество кластеров]
| pf_height = <math>2i</math>
| pf_width = <math>n</math>
}}

Авторы : [[Участник:Gkhazeeva|Гелана Хазеева]] ([[#Вычислительное ядро алгоритма|1.3]]; [[1.5]]; [[1.6]]; [[1.7]]; [[2.4]]; [[2.7]]), [[Участник:Yushin|Павел Юшин]] ([[1.1]]; [[1.2]]; [[1.4]]; [[1.8]]; [[1.9]]; [[1.10]])

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

== Общее описание алгоритма ==
Кластеризация - это объединение объектов в группы (кластеры) на основе схожести признаков для объектов одной группы и отличий между группами. Нечеткий алгоритм C Средних (Fuzzy C-means, FCM) - алгоритм кластеризации, позволяющий объектам принадлежать с различной степенью нескольким кластерам одновременно. Впервые алгоритм был предложен J.C. Dunn в 1973 <ref>{{Cite journal|last=Dunn|first=J. C.|date=1973-01-01|title=A Fuzzy Relative of the ISODATA Process and Its Use in Detecting Compact Well-Separated Clusters|url=http://dx.doi.org/10.1080/01969727308546046|journal=Journal of Cybernetics|volume=3|issue=3|pages=32–57|doi=10.1080/01969727308546046|issn=0022-0280}}</ref>. Нечеткое разбиение позволяет просто решить проблему объектов, расположенных на границе двух кластеров - им назначают степени принадлежностей равные 0.5.

Входные данные алгоритма: набор векторов, которые следует кластеризовать.

Параметры алгоритма: <math>c</math> - количество кластеров; <math>m</math> - экспоненциальный вес; <math>\varepsilon</math> - параметр останова алгоритма.

Выходные данные: матрица вероятностей принадлежности векторов кластерам.

Краткое описание алгоритма:

* Задать параметры алгоритма.

* Сгенерировать случайную матрицу принадлежностей векторов кластерам (матрицу нечеткого разбиения).

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

== Математическое описание алгоритма <ref>http://it-claim.ru/Persons/Neyskiy/Article2_Neiskiy.pdf</ref> ==

Пусть <math> W = w_{ij} \in[0,1],\; i = 1, ..., M, \; j = 1, ..., c</math> - матрица разбиения, где <math>w_{i,j}</math> - степень принадлежности объекта <math>i</math> к кластеру <math>j</math>; <math>c</math> - количество кластеров, <math>M</math> - количество векторов.

При этом элементы матрицы должны удовлетворять условиям:

* <math>\sum_{j = 1}^c w_{ij} = 1, i = 1, ..., M</math>                <math>(1)</math>
* <math>0 < \sum_{i = 1}^M w_{ij} < M, j = 1, ..., c</math>       <math>(2)</math>

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

1) Задаем параметры алгоритма: <math>c</math> - количество кластеров; <math>m >= 1</math> - экспоненциальный вес, определяющий нечеткость кластеров; <math>\varepsilon > 0</math> - параметр останова алгоритма.

2) Генерируем случайным образом матрицу нечеткого разбиения с учетом условий <math>(1)</math> и <math>(2)</math>

3) Рассчитываем центроиды (центры кластеров): <math>V_j = {{\sum_{i=1}^M w_{ij}^m * X_i} \over {\sum_{i=1}^M w_{ij}^m}}, j = 1, ..., c</math>

4) Рассчитываем расстояния между объектами <math>X</math> и центроидами:

<math>D_{ij} = {||X_i - V_j||}, i = 1,...,M; j = 1,...,c </math>

5) Пересчет элементов матрицы разбиения:

при <math>D_{ij} >0</math> : <math>w_{ij} = {{1}\over {{ (\sum_{k=1}^c {{D_{ij}}\over{D_{ik}}} ) }^{2/(m-1)}}}, j = 1,...,c</math>

при <math>D_{ij} =0</math> : <math>w_{ij} = \delta_{ij}, j = 1,...,c</math>, где <math>\delta_{ij}</math> - символ Кронекера

6) Если <math>|| F - F^{*} || < \varepsilon </math>, где <math>F^{*}</math> - матрица нечеткого разбиения предыдущей итерации, то идем далее, иначе возвращаемся на пункт 3.

7) Конец.

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

Вычислительным ядром алгоритма являются пункты (3), (4), (5) - расчет центроидов, вычисление расстояний и пересчет элементов матрицы соответственно

== Макроструктура алгоритма ==
Основные шаги при реализации алгоритма
* Генерация случайной матрицы размера <math>M</math> на где <math>c</math>, проверка условий
* Расчет центроидов – по сути, скалярное произведение с нормировкой
* Расчет расстояний – в общепринятом случае является скалярным произведением
* Пересчет матрицы – по сути, скалярное произведение
* Проверка условий останова – вычисление нормы

== Схема реализации последовательного алгоритма ==
float ** FuzzyCMeans (float** X, c, m, eps){
n = X.size();
r = X[0].size();
centers = generateZeroFill(c, r)
Wprev = genetateRandFill(n, c);
W = Wprev;
while (true){
// обновляем центры кластеров
for (int i=0; i<c; i++){
float * num = new float []();
float den = 0;
for (int j=0; j<n; j++){
num += pow(W[j][i], m) * X[j];
den+=pow(W[j][i], m);
}
centers[i] = num / den;
}
//обновляем вероятности W и считаем расстояние между матрицами W и Wprev
float max_diff = 0;
for (int i=0; i<n; i++)
for (int j=0; j<c; j++){
total = 0;
for (int m=0; m<с; m++)
total += pow(distance(X[i], centers[j]) / distance(X[i], centers[m]), 2/(m-1));
W[i][j] = 1/total;
max_diff = max(abs(Wprev[i][j]-W[i][j]), max_diff);
Wprev[i][j] = W[i][j];
}
if (max_diff < eps):
break;
}
return W;
}

== Последовательная сложность алгоритма ==
Последовательная сложность алгоритма состоит из сложности каждой итерации умноженной на их количество. Так как число итераций заранее неизвестно и зависит от входных параметров, рассмотрим сложность на каждой итерации. Наибольшую сложность представляет собой пересчет матрицы, сложность которого <math>O(c^2 nd)</math> (по сравнению со сложностью <math>O(cnd)</math> расчета расстояний, вычисления центроидов и проверки условия останова). Итого общая сложность алгоритма <math>O(c^2 ndi)</math>

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

'''Первый ярус''' состоит из <math>M</math> параллельных операций 1, 2, совершаемых в цикле <math>c</math> раз для каждого кластера.

'''Операция 1''': <math>w_{ij}^m</math>, где <math>j</math> - номер итерации в цикле, <math>i</math> - номер параллельной ветви.

'''Операция 2''': <math>w_{ij}^m*X_i</math>

Здесь <math>j</math> - номер итерации в цикле, <math>i</math> - номер параллельной ветви.

На выходе из каждой ветки получаем вектор размера <math>1</math> x <math>c</math> и матрицу размера <math>d</math> x <math>c</math>.
Далее совершаем поэлементное сложение векторов и матриц соответственно, а затем делим каждый столбец в матрице на соответствующий элемент в векторе.

'''Второй ярус''' состоит их <math>M</math> параллельных операций 3, 4, 5 также совершаемых в цикле <math>c</math> раз.

'''Операция 4''': обновление значения <math>w_{ij}</math> по указанной в разделе 1.2 в пункте 5 формуле.

'''Операция 5''': <math>maximum = max(|w_{ij} - w_{ij}^{prev}|, maximum)</math>.

'''Операция 6''': <math>w_{ij}^{prev} = w_{ij}</math>.

Здесь <math>j</math> - номер итерации в цикле, <math>i</math> - номер параллельной ветви.

На выходе из каждой ветки получаем число <math>maximum</math>. Далее находим максимальное значение из полученных величин для каждой ветки. Затем проверяем условие останова алгоритма.

[[File:Scheme.JPG]]

== Ресурс параллелизма алгоритма ==
Параллельная сложность алгоритма: <math>M*c^2*i</math>. Такая сложность получается за счет распараллеливания на каждом ярусе <math>M</math> операций. Иерархическая структура параллелизма подробно описана в [[#Информационный граф|п.1.7]].

В алгоритме не возникает скошенного параллелизма.

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

* Входные данные алгоритма: набор векторов <math>x_i</math> размерности <math>d</math>, где <math>i = 1,...,M</math>; <math>M</math> - количество векторов.
* Выходные данные алгоритма: матрица вероятностей принадлежности векторов кластерам <math>M</math> на <math>c</math>.

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

* Соотношение последовательной и параллельной формы алгоритма: <math>M</math>
* Вычислительная мощность: <math>{dc^2i} \over {c+d}</math>.
* Устойчивость: алгоритм не является устойчивым, поэтому существует много исследований о том, как первоначально выбрать параметры кластеризации.
* Сбалансированность: в данном алгоритме операция умножения доминирует над операцией сложения. Операции между параллельными ветвями сбалансированны.
* Детерминированность: алгоритм не является детерминированным, так как матрица нечеткого разбиение генерируется произвольно.
* Степень исхода вершины информационного графа ( для одной интерации): 2 (3 - с учетом, если выходные данные пошли на следующую итерацию).

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

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

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

* Реализация алгоритма на POSTGRESQL: http://num-meth.srcc.msu.ru/zhurnal/tom_2012/pdf/v13r207.pdf
* Библиотека для MATLAB: http://www.mathworks.com/help/fuzzy/fcm.html (распространяется на коммерческой основе)

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

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

2016-10-28T16:06:40Z

Yushin:

{{algorithm
| name = Нечеткий алгоритм C средних
| serial_complexity = <math>O(Mdc^2i)</math>, <math>i</math> - количество итераций
| input_data = <math>M*d</math>, [количество наблюдений * размерность]
| output_data = <math>M*c</math>, [количество наблюдений * количество кластеров]
| pf_height = <math>2i</math>
| pf_width = <math>n</math>
}}

Авторы : [[Участник:Gkhazeeva|Гелана Хазеева]] (1.3; 1.5; 1.6; 1.7; 2.4; 2.7), [[Участник:Yushin|Павел Юшин]] (1.1; 1.2; 1.4; 1.8; 1.9; 1.10)

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

== Общее описание алгоритма ==
Кластеризация - это объединение объектов в группы (кластеры) на основе схожести признаков для объектов одной группы и отличий между группами. Нечеткий алгоритм C Средних (Fuzzy C-means, FCM) - алгоритм кластеризации, позволяющий объектам принадлежать с различной степенью нескольким кластерам одновременно. Впервые алгоритм был предложен J.C. Dunn в 1973 <ref>{{Cite journal|last=Dunn|first=J. C.|date=1973-01-01|title=A Fuzzy Relative of the ISODATA Process and Its Use in Detecting Compact Well-Separated Clusters|url=http://dx.doi.org/10.1080/01969727308546046|journal=Journal of Cybernetics|volume=3|issue=3|pages=32–57|doi=10.1080/01969727308546046|issn=0022-0280}}</ref>. Нечеткое разбиение позволяет просто решить проблему объектов, расположенных на границе двух кластеров - им назначают степени принадлежностей равные 0.5.

Входные данные алгоритма: набор векторов, которые следует кластеризовать.

Параметры алгоритма: <math>c</math> - количество кластеров; <math>m</math> - экспоненциальный вес; <math>\varepsilon</math> - параметр останова алгоритма.

Выходные данные: матрица вероятностей принадлежности векторов кластерам.

Краткое описание алгоритма:

* Задать параметры алгоритма.

* Сгенерировать случайную матрицу принадлежностей векторов кластерам (матрицу нечеткого разбиения).

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

== Математическое описание алгоритма <ref>http://it-claim.ru/Persons/Neyskiy/Article2_Neiskiy.pdf</ref> ==

Пусть <math> W = w_{ij} \in[0,1],\; i = 1, ..., M, \; j = 1, ..., c</math> - матрица разбиения, где <math>w_{i,j}</math> - степень принадлежности объекта <math>i</math> к кластеру <math>j</math>; <math>c</math> - количество кластеров, <math>M</math> - количество векторов.

При этом элементы матрицы должны удовлетворять условиям:

* <math>\sum_{j = 1}^c w_{ij} = 1, i = 1, ..., M</math>                <math>(1)</math>
* <math>0 < \sum_{i = 1}^M w_{ij} < M, j = 1, ..., c</math>       <math>(2)</math>

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

1) Задаем параметры алгоритма: <math>c</math> - количество кластеров; <math>m >= 1</math> - экспоненциальный вес, определяющий нечеткость кластеров; <math>\varepsilon > 0</math> - параметр останова алгоритма.

2) Генерируем случайным образом матрицу нечеткого разбиения с учетом условий <math>(1)</math> и <math>(2)</math>

3) Рассчитываем центроиды (центры кластеров): <math>V_j = {{\sum_{i=1}^M w_{ij}^m * X_i} \over {\sum_{i=1}^M w_{ij}^m}}, j = 1, ..., c</math>

4) Рассчитываем расстояния между объектами <math>X</math> и центроидами:

<math>D_{ij} = {||X_i - V_j||}, i = 1,...,M; j = 1,...,c </math>

5) Пересчет элементов матрицы разбиения:

при <math>D_{ij} >0</math> : <math>w_{ij} = {{1}\over {{ (\sum_{k=1}^c {{D_{ij}}\over{D_{ik}}} ) }^{2/(m-1)}}}, j = 1,...,c</math>

при <math>D_{ij} =0</math> : <math>w_{ij} = \delta_{ij}, j = 1,...,c</math>, где <math>\delta_{ij}</math> - символ Кронекера

6) Если <math>|| F - F^{*} || < \varepsilon </math>, где <math>F^{*}</math> - матрица нечеткого разбиения предыдущей итерации, то идем далее, иначе возвращаемся на пункт 3.

7) Конец.

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

Вычислительным ядром алгоритма являются пункты (3), (4), (5) - расчет центроидов, вычисление расстояний и пересчет элементов матрицы соответственно

== Макроструктура алгоритма ==
Основные шаги при реализации алгоритма
* Генерация случайной матрицы размера <math>M</math> на где <math>c</math>, проверка условий
* Расчет центроидов – по сути, скалярное произведение с нормировкой
* Расчет расстояний – в общепринятом случае является скалярным произведением
* Пересчет матрицы – по сути, скалярное произведение
* Проверка условий останова – вычисление нормы

== Схема реализации последовательного алгоритма ==
float ** FuzzyCMeans (float** X, c, m, eps){
n = X.size();
r = X[0].size();
centers = generateZeroFill(c, r)
Wprev = genetateRandFill(n, c);
W = Wprev;
while (true){
// обновляем центры кластеров
for (int i=0; i<c; i++){
float * num = new float []();
float den = 0;
for (int j=0; j<n; j++){
num += pow(W[j][i], m) * X[j];
den+=pow(W[j][i], m);
}
centers[i] = num / den;
}
//обновляем вероятности W и считаем расстояние между матрицами W и Wprev
float max_diff = 0;
for (int i=0; i<n; i++)
for (int j=0; j<c; j++){
total = 0;
for (int m=0; m<с; m++)
total += pow(distance(X[i], centers[j]) / distance(X[i], centers[m]), 2/(m-1));
W[i][j] = 1/total;
max_diff = max(abs(Wprev[i][j]-W[i][j]), max_diff);
Wprev[i][j] = W[i][j];
}
if (max_diff < eps):
break;
}
return W;
}

== Последовательная сложность алгоритма ==
Последовательная сложность алгоритма состоит из сложности каждой итерации умноженной на их количество. Так как число итераций заранее неизвестно и зависит от входных параметров, рассмотрим сложность на каждой итерации. Наибольшую сложность представляет собой пересчет матрицы, сложность которого <math>O(c^2 nd)</math> (по сравнению со сложностью <math>O(cnd)</math> расчета расстояний, вычисления центроидов и проверки условия останова). Итого общая сложность алгоритма <math>O(c^2 ndi)</math>

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

'''Первый ярус''' состоит из <math>M</math> параллельных операций 1, 2, совершаемых в цикле <math>c</math> раз для каждого кластера.

'''Операция 1''': <math>w_{ij}^m</math>, где <math>j</math> - номер итерации в цикле, <math>i</math> - номер параллельной ветви.

'''Операция 2''': <math>w_{ij}^m*X_i</math>

Здесь <math>j</math> - номер итерации в цикле, <math>i</math> - номер параллельной ветви.

На выходе из каждой ветки получаем вектор размера <math>1</math> x <math>c</math> и матрицу размера <math>d</math> x <math>c</math>.
Далее совершаем поэлементное сложение векторов и матриц соответственно, а затем делим каждый столбец в матрице на соответствующий элемент в векторе.

'''Второй ярус''' состоит их <math>M</math> параллельных операций 3, 4, 5 также совершаемых в цикле <math>c</math> раз.

'''Операция 4''': обновление значения <math>w_{ij}</math> по указанной в разделе 1.2 в пункте 5 формуле.

'''Операция 5''': <math>maximum = max(|w_{ij} - w_{ij}^{prev}|, maximum)</math>.

'''Операция 6''': <math>w_{ij}^{prev} = w_{ij}</math>.

Здесь <math>j</math> - номер итерации в цикле, <math>i</math> - номер параллельной ветви.

На выходе из каждой ветки получаем число <math>maximum</math>. Далее находим максимальное значение из полученных величин для каждой ветки. Затем проверяем условие останова алгоритма.

[[File:Scheme.JPG]]

== Ресурс параллелизма алгоритма ==
Параллельная сложность алгоритма: <math>M*c^2*i</math>. Такая сложность получается за счет распараллеливания на каждом ярусе <math>M</math> операций. Иерархическая структура параллелизма подробно описана в [[#Информационный граф|п.1.7]].

В алгоритме не возникает скошенного параллелизма.

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

* Входные данные алгоритма: набор векторов <math>x_i</math> размерности <math>d</math>, где <math>i = 1,...,M</math>; <math>M</math> - количество векторов.
* Выходные данные алгоритма: матрица вероятностей принадлежности векторов кластерам <math>M</math> на <math>c</math>.

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

* Соотношение последовательной и параллельной формы алгоритма: <math>M</math>
* Вычислительная мощность: <math>{dc^2i} \over {c+d}</math>.
* Устойчивость: алгоритм не является устойчивым, поэтому существует много исследований о том, как первоначально выбрать параметры кластеризации.
* Сбалансированность: в данном алгоритме операция умножения доминирует над операцией сложения. Операции между параллельными ветвями сбалансированны.
* Детерминированность: алгоритм не является детерминированным, так как матрица нечеткого разбиение генерируется произвольно.
* Степень исхода вершины информационного графа ( для одной интерации): 2 (3 - с учетом, если выходные данные пошли на следующую итерацию).

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

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

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

* Реализация алгоритма на POSTGRESQL: http://num-meth.srcc.msu.ru/zhurnal/tom_2012/pdf/v13r207.pdf
* Библиотека для MATLAB: http://www.mathworks.com/help/fuzzy/fcm.html (распространяется на коммерческой основе)

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

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

2016-10-28T15:57:33Z

Yushin:

{{algorithm
| name = Нечеткий алгоритм C средних
| serial_complexity = <math>O(Mdc^2i)</math>, <math>i</math> - количество итераций
| input_data = <math>M*d</math>, [количество наблюдений * размерность]
| output_data = <math>M*c</math>, [количество наблюдений * количество кластеров]
| pf_height = <math>2i</math>
| pf_width = <math>n</math>
}}

Авторы : [[Участник:Gkhazeeva|Гелана Хазеева]], [[Участник:Yushin|Павел Юшин]]

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

== Общее описание алгоритма ==
Кластеризация - это объединение объектов в группы (кластеры) на основе схожести признаков для объектов одной группы и отличий между группами. Нечеткий алгоритм C Средних (Fuzzy C-means, FCM) - алгоритм кластеризации, позволяющий объектам принадлежать с различной степенью нескольким кластерам одновременно. Впервые алгоритм был предложен J.C. Dunn в 1973 <ref>{{Cite journal|last=Dunn|first=J. C.|date=1973-01-01|title=A Fuzzy Relative of the ISODATA Process and Its Use in Detecting Compact Well-Separated Clusters|url=http://dx.doi.org/10.1080/01969727308546046|journal=Journal of Cybernetics|volume=3|issue=3|pages=32–57|doi=10.1080/01969727308546046|issn=0022-0280}}</ref>. Нечеткое разбиение позволяет просто решить проблему объектов, расположенных на границе двух кластеров - им назначают степени принадлежностей равные 0.5.

Входные данные алгоритма: набор векторов, которые следует кластеризовать.

Параметры алгоритма: <math>c</math> - количество кластеров; <math>m</math> - экспоненциальный вес; <math>\varepsilon</math> - параметр останова алгоритма.

Выходные данные: матрица вероятностей принадлежности векторов кластерам.

Краткое описание алгоритма:

* Задать параметры алгоритма.

* Сгенерировать случайную матрицу принадлежностей векторов кластерам (матрицу нечеткого разбиения).

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

== Математическое описание алгоритма <ref>http://it-claim.ru/Persons/Neyskiy/Article2_Neiskiy.pdf</ref> ==

Пусть <math> W = w_{ij} \in[0,1],\; i = 1, ..., M, \; j = 1, ..., c</math> - матрица разбиения, где <math>w_{i,j}</math> - степень принадлежности объекта <math>i</math> к кластеру <math>j</math>; <math>c</math> - количество кластеров, <math>M</math> - количество векторов.

При этом элементы матрицы должны удовлетворять условиям:

* <math>\sum_{j = 1}^c w_{ij} = 1, i = 1, ..., M</math>                <math>(1)</math>
* <math>0 < \sum_{i = 1}^M w_{ij} < M, j = 1, ..., c</math>       <math>(2)</math>

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

1) Задаем параметры алгоритма: <math>c</math> - количество кластеров; <math>m >= 1</math> - экспоненциальный вес, определяющий нечеткость кластеров; <math>\varepsilon > 0</math> - параметр останова алгоритма.

2) Генерируем случайным образом матрицу нечеткого разбиения с учетом условий <math>(1)</math> и <math>(2)</math>

3) Рассчитываем центроиды (центры кластеров): <math>V_j = {{\sum_{i=1}^M w_{ij}^m * X_i} \over {\sum_{i=1}^M w_{ij}^m}}, j = 1, ..., c</math>

4) Рассчитываем расстояния между объектами <math>X</math> и центроидами:

<math>D_{ij} = {||X_i - V_j||}, i = 1,...,M; j = 1,...,c </math>

5) Пересчет элементов матрицы разбиения:

при <math>D_{ij} >0</math> : <math>w_{ij} = {{1}\over {{ (\sum_{k=1}^c {{D_{ij}}\over{D_{ik}}} ) }^{2/(m-1)}}}, j = 1,...,c</math>

при <math>D_{ij} =0</math> : <math>w_{ij} = \delta_{ij}, j = 1,...,c</math>, где <math>\delta_{ij}</math> - символ Кронекера

6) Если <math>|| F - F^{*} || < \varepsilon </math>, где <math>F^{*}</math> - матрица нечеткого разбиения предыдущей итерации, то идем далее, иначе возвращаемся на пункт 3.

7) Конец.

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

Вычислительным ядром алгоритма являются пункты (3), (4), (5) - расчет центроидов, вычисление расстояний и пересчет элементов матрицы соответственно

== Макроструктура алгоритма ==
Основные шаги при реализации алгоритма
* Генерация случайной матрицы размера <math>M</math> на где <math>c</math>, проверка условий
* Расчет центроидов – по сути, скалярное произведение с нормировкой
* Расчет расстояний – в общепринятом случае является скалярным произведением
* Пересчет матрицы – по сути, скалярное произведение
* Проверка условий останова – вычисление нормы

== Схема реализации последовательного алгоритма ==
float ** FuzzyCMeans (float** X, c, m, eps){
n = X.size();
r = X[0].size();
centers = generateZeroFill(c, r)
Wprev = genetateRandFill(n, c);
W = Wprev;
while (true){
// обновляем центры кластеров
for (int i=0; i<c; i++){
float * num = new float []();
float den = 0;
for (int j=0; j<n; j++){
num += pow(W[j][i], m) * X[j];
den+=pow(W[j][i], m);
}
centers[i] = num / den;
}
//обновляем вероятности W и считаем расстояние между матрицами W и Wprev
float max_diff = 0;
for (int i=0; i<n; i++)
for (int j=0; j<c; j++){
total = 0;
for (int m=0; m<с; m++)
total += pow(distance(X[i], centers[j]) / distance(X[i], centers[m]), 2/(m-1));
W[i][j] = 1/total;
max_diff = max(abs(Wprev[i][j]-W[i][j]), max_diff);
Wprev[i][j] = W[i][j];
}
if (max_diff < eps):
break;
}
return W;
}

== Последовательная сложность алгоритма ==
Последовательная сложность алгоритма состоит из сложности каждой итерации умноженной на их количество. Так как число итераций заранее неизвестно и зависит от входных параметров, рассмотрим сложность на каждой итерации. Наибольшую сложность представляет собой пересчет матрицы, сложность которого <math>O(c^2 nd)</math> (по сравнению со сложностью <math>O(cnd)</math> расчета расстояний, вычисления центроидов и проверки условия останова). Итого общая сложность алгоритма <math>O(c^2 ndi)</math>

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

'''Первый ярус''' состоит из <math>M</math> параллельных операций 1, 2, совершаемых в цикле <math>c</math> раз для каждого кластера.

'''Операция 1''': <math>w_{ij}^m</math>, где <math>j</math> - номер итерации в цикле, <math>i</math> - номер параллельной ветви.

'''Операция 2''': <math>w_{ij}^m*X_i</math>

Здесь <math>j</math> - номер итерации в цикле, <math>i</math> - номер параллельной ветви.

На выходе из каждой ветки получаем вектор размера <math>1</math> x <math>c</math> и матрицу размера <math>d</math> x <math>c</math>.
Далее совершаем поэлементное сложение векторов и матриц соответственно, а затем делим каждый столбец в матрице на соответствующий элемент в векторе.

'''Второй ярус''' состоит их <math>M</math> параллельных операций 3, 4, 5 также совершаемых в цикле <math>c</math> раз.

'''Операция 4''': обновление значения <math>w_{ij}</math> по указанной в разделе 1.2 в пункте 5 формуле.

'''Операция 5''': <math>maximum = max(|w_{ij} - w_{ij}^{prev}|, maximum)</math>.

'''Операция 6''': <math>w_{ij}^{prev} = w_{ij}</math>.

Здесь <math>j</math> - номер итерации в цикле, <math>i</math> - номер параллельной ветви.

На выходе из каждой ветки получаем число <math>maximum</math>. Далее находим максимальное значение из полученных величин для каждой ветки. Затем проверяем условие останова алгоритма.

[[File:Scheme.JPG]]

== Ресурс параллелизма алгоритма ==
Параллельная сложность алгоритма: <math>M*c^2*i</math>. Такая сложность получается за счет распараллеливания на каждом ярусе <math>M</math> операций. Иерархическая структура параллелизма подробно описана в [[#Информационный граф|п.1.7]].

В алгоритме не возникает скошенного параллелизма.

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

* Входные данные алгоритма: набор векторов <math>x_i</math> размерности <math>d</math>, где <math>i = 1,...,M</math>; <math>M</math> - количество векторов.
* Выходные данные алгоритма: матрица вероятностей принадлежности векторов кластерам <math>M</math> на <math>c</math>.

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

* Соотношение последовательной и параллельной формы алгоритма: <math>M</math>
* Вычислительная мощность: <math>{dc^2i} \over {c+d}</math>.
* Устойчивость: алгоритм не является устойчивым, поэтому существует много исследований о том, как первоначально выбрать параметры кластеризации.
* Сбалансированность: в данном алгоритме операция умножения доминирует над операцией сложения. Операции между параллельными ветвями сбалансированны.
* Детерминированность: алгоритм не является детерминированным, так как матрица нечеткого разбиение генерируется произвольно.
* Степень исхода вершины информационного графа ( для одной интерации): 2 (3 - с учетом, если выходные данные пошли на следующую итерацию).

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

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

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

* Реализация алгоритма на POSTGRESQL: http://num-meth.srcc.msu.ru/zhurnal/tom_2012/pdf/v13r207.pdf
* Библиотека для MATLAB: http://www.mathworks.com/help/fuzzy/fcm.html (распространяется на коммерческой основе)

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

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

2016-10-15T12:45:16Z

Yushin:

{{Assignment}}

{{algorithm
| name = Нечеткий алгоритм C средних
| serial_complexity = <math>O(Mdc^2i)</math>, <math>i</math> - количество итераций
| input_data = <math>M*d</math>, [количество наблюдений * размерность]
| output_data = <math>M*c</math>, [количество наблюдений * количество кластеров]
| pf_height = <math>2i</math>
| pf_width = <math>n</math>
}}

Авторы : [[Участник:Gkhazeeva|Гелана Хазеева]], [[Участник:Yushin|Павел Юшин]]

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

== Общее описание алгоритма ==
Кластеризация - это объединение объектов в группы (кластеры) на основе схожести признаков для объектов одной группы и отличий между группами. Нечеткий алгоритм C Средних (Fuzzy C-means, FCM) - алгоритм кластеризации, позволяющий объектам принадлежать с различной степенью нескольким кластерам одновременно. Впервые алгоритм был предложен J.C. Dunn в 1973 <ref>{{Cite journal|last=Dunn|first=J. C.|date=1973-01-01|title=A Fuzzy Relative of the ISODATA Process and Its Use in Detecting Compact Well-Separated Clusters|url=http://dx.doi.org/10.1080/01969727308546046|journal=Journal of Cybernetics|volume=3|issue=3|pages=32–57|doi=10.1080/01969727308546046|issn=0022-0280}}</ref>. Нечеткое разбиение позволяет просто решить проблему объектов, расположенных на границе двух кластеров - им назначают степени принадлежностей равные 0.5.

Входные данные алгоритма: набор векторов, которые следует кластеризовать.

Параметры алгоритма: <math>c</math> - количество кластеров; <math>m</math> - экспоненциальный вес; <math>\varepsilon</math> - параметр останова алгоритма.

Выходные данные: матрица вероятностей принадлежности векторов кластерам.

Краткое описание алгоритма:

* Задать параметры алгоритма.

* Сгенерировать случайную матрицу принадлежностей векторов кластерам (матрицу нечеткого разбиения).

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

== Математическое описание алгоритма <ref>http://it-claim.ru/Persons/Neyskiy/Article2_Neiskiy.pdf</ref> ==

Пусть <math> W = w_{ij} \in[0,1],\; i = 1, ..., M, \; j = 1, ..., c</math> - матрица разбиения, где <math>w_{i,j}</math> - степень принадлежности объекта <math>i</math> к кластеру <math>j</math>; <math>c</math> - количество кластеров, <math>M</math> - количество векторов.

При этом элементы матрицы должны удовлетворять условиям:

* <math>\sum_{j = 1}^c w_{ij} = 1, i = 1, ..., M</math> <math>(1)</math>
* <math>0 < \sum_{i = 1}^M w_{ij} < M, j = 1, ..., c</math> <math>(2)</math>

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

1) Задаем параметры алгоритма: <math>c</math> - количество кластеров; <math>m >= 1</math> - экспоненциальный вес, определяющий нечеткость кластеров; <math>\varepsilon > 0</math> - параметр останова алгоритма.

2) Генерируем случайным образом матрицу нечеткого разбиения с учетом условий <math>(1)</math> и <math>(2)</math>

3) Рассчитываем центроиды (центры кластеров): <math>V_j = {{\sum_{i=1}^M w_{ij}^m * X_i} \over {\sum_{i=1}^M w_{ij}^m}}, j = 1, ..., c</math>

4) Рассчитываем расстояния между объектами <math>X</math> и центроидами:

<math>D_{ij} = {||X_i - V_j||}, i = 1,...,M; j = 1,...,c </math>

5) Пересчет элементов матрицы разбиения:

при <math>D_{ij} >0</math> : <math>w_{ij} = {{1}\over {{ (\sum_{k=1}^c {{D_{ij}}\over{D_{ik}}} ) }^{2/(m-1)}}}, j = 1,...,c</math>

при <math>D_{ij} =0</math> : <math>w_{ij} = \delta_{ij}, j = 1,...,c</math>, где <math>\delta_{ij}</math> - символ Кронекера

6) Если <math>|| F - F^{*} || < \varepsilon </math>, где <math>F^{*}</math> - матрица нечеткого разбиения предыдущей итерации, то идем далее, иначе возвращаемся на пункт 3.

7) Конец.

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

Вычислительным ядром алгоритма являются пункты (3), (4), (5) - расчет центроидов, вычисление расстояний и пересчет элементов матрицы соответственно

== Макроструктура алгоритма ==
Основные шаги при реализации алгоритма
* Генерация случайной матрицы размера <math>M</math> на где <math>c</math>, проверка условий
* Расчет центроидов – по сути, скалярное произведение с нормировкой
* Расчет расстояний – в общепринятом случае является скалярным произведением
* Пересчет матрицы – по сути, скалярное произведение
* Проверка условий останова – вычисление нормы

== Схема реализации последовательного алгоритма ==
float ** FuzzyCMeans (float** X, c, m, eps){
n = X.size();
r = X[0].size();
centers = generateZeroFill(c, r)
Wprev = genetateRandFill(n, c);
W = Wprev;
while (true){
// обновляем центры кластеров
for (int i=0; i<c; i++){
float * num = new float []();
float den = 0;
for (int j=0; j<n; j++){
num += pow(W[j][i], m) * X[j];
den+=pow(W[j][i], m);
}
centers[i] = num / den;
}
//обновляем вероятности W и считаем расстояние между матрицами W и Wprev
float max_diff = 0;
for (int i=0; i<n; i++)
for (int j=0; j<c; j++){
total = 0;
for (int m=0; m<с; m++)
total += pow(distance(X[i], centers[j]) / distance(X[i], centers[m]), 2/(m-1));
W[i][j] = 1/total;
max_diff = max(abs(Wprev[i][j]-W[i][j]), max_diff);
Wprev[i][j] = W[i][j];
}
if (max_diff < eps):
break;
}
return W;
}

== Последовательная сложность алгоритма ==
Последовательная сложность алгоритма состоит из сложности каждой итерации умноженной на их количество. Так как число итераций заранее неизвестно и зависит от входных параметров, рассмотрим сложность на каждой итерации. Наибольшую сложность представляет собой пересчет матрицы, сложность которого <math>O(c^2 nd)</math> (по сравнению со сложностью <math>O(cnd)</math> расчета расстояний, вычисления центроидов и проверки условия останова). Итого общая сложность алгоритма <math>O(c^2 ndi)</math>

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

'''Первый ярус''' состоит из <math>M</math> параллельных операций 1, 2, совершаемых в цикле <math>c</math> раз для каждого кластера.

'''Операция 1''': <math>w_{ij}^m</math>, где <math>j</math> - номер итерации в цикле, <math>i</math> - номер параллельной ветви.

'''Операция 2''': <math>w_{ij}^m*X_i</math>

Здесь <math>j</math> - номер итерации в цикле, <math>i</math> - номер параллельной ветви.

На выходе из каждой ветки получаем вектор размера <math>1</math> x <math>c</math> и матрицу размера <math>d</math> x <math>c</math>.
Далее совершаем поэлементное сложение векторов и матриц соответственно, а затем делим каждый столбец в матрице на соответствующий элемент в векторе.

'''Второй ярус''' состоит их <math>M</math> параллельных операций 3, 4, 5 также совершаемых в цикле <math>c</math> раз.

'''Операция 4''': обновление значения <math>w_{ij}</math> по указанной в разделе 1.2 в пункте 5 формуле.

'''Операция 5''': <math>maximum = max(|w_{ij} - w_{ij}^{prev}|, maximum)</math>.

'''Операция 6''': <math>w_{ij}^{prev} = w_{ij}</math>.

Здесь <math>j</math> - номер итерации в цикле, <math>i</math> - номер параллельной ветви.

На выходе из каждой ветки получаем число <math>maximum</math>. Далее находим максимальное значение из полученных величин для каждой ветки. Затем проверяем условие останова алгоритма.

[[File:Scheme.JPG]]

== Ресурс параллелизма алгоритма ==
Параллельная сложность алгоритма: <math>M*c^2*i</math>. Такая сложность получается за счет распараллеливания на каждом ярусе <math>M</math> операций. Иерархическая структура параллелизма подробно описана в [[#Информационный граф|п.1.7]].

В алгоритме не возникает скошенного параллелизма.

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

* Входные данные алгоритма: набор векторов <math>x_i</math> размерности <math>d</math>, где <math>i = 1,...,M</math>; <math>M</math> - количество векторов.
* Выходные данные алгоритма: матрица вероятностей принадлежности векторов кластерам <math>M</math> на <math>c</math>.

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

* Соотношение последовательной и параллельной формы алгоритма: <math>M</math>
* Вычислительная мощность: <math>{dc^2i} \over {c+d}</math>.
* Устойчивость: алгоритм не является устойчивым, поэтому существует много исследований о том, как первоначально выбрать параметры кластеризации.
* Сбалансированность: в данном алгоритме операция умножения доминирует над операцией сложения. Операции между параллельными ветвями сбалансированны.
* Детерминированность: алгоритм не является детерминированным, так как матрица нечеткого разбиение генерируется произвольно.
* Степень исхода вершины информационного графа ( для одной интерации): 2 (3 - с учетом, если выходные данные пошли на следующую итерацию).

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

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

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

* Реализация алгоритма на POSTGRESQL: http://num-meth.srcc.msu.ru/zhurnal/tom_2012/pdf/v13r207.pdf
* Библиотека для MATLAB: http://www.mathworks.com/help/fuzzy/fcm.html (распространяется на коммерческой основе)

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

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

2016-10-15T12:43:44Z

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

{{algorithm
| name = Нечеткий алгоритм C средних
| serial_complexity = <math>O(Mdc^2i)</math>, <math>i</math> - количество итераций
| input_data = <math>M*d</math>, [количество наблюдений * размерность]
| output_data = <math>M*c</math>, [количество наблюдений * количество кластеров]
| pf_height = <math>2i</math>
| pf_width = <math>n</math>
}}

Авторы : [[Участник:Gkhazeeva|Гелана Хазеева]], [[Участник:Yushin|Павел Юшин]]

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

== Общее описание алгоритма ==
Кластеризация - это объединение объектов в группы (кластеры) на основе схожести признаков для объектов одной группы и отличий между группами. Нечеткий алгоритм C Средних (Fuzzy C-means, FCM) - алгоритм кластеризации, позволяющий объектам принадлежать с различной степенью нескольким кластерам одновременно. Впервые алгоритм был предложен J.C. Dunn в 1973 <ref>{{Cite journal|last=Dunn|first=J. C.|date=1973-01-01|title=A Fuzzy Relative of the ISODATA Process and Its Use in Detecting Compact Well-Separated Clusters|url=http://dx.doi.org/10.1080/01969727308546046|journal=Journal of Cybernetics|volume=3|issue=3|pages=32–57|doi=10.1080/01969727308546046|issn=0022-0280}}</ref>. Нечеткое разбиение позволяет просто решить проблему объектов, расположенных на границе двух кластеров - им назначают степени принадлежностей равные 0.5.

Входные данные алгоритма: набор векторов, которые следует кластеризовать.

Параметры алгоритма: <math>c</math> - количество кластеров; <math>m</math> - экспоненциальный вес; <math>\varepsilon</math> - параметр останова алгоритма.

Выходные данные: матрица вероятностей принадлежности векторов кластерам.

Краткое описание алгоритма:

* Задать параметры алгоритма.

* Сгенерировать случайную матрицу принадлежностей векторов кластерам (матрицу нечеткого разбиения).

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

== Математическое описание алгоритма <ref>http://it-claim.ru/Persons/Neyskiy/Article2_Neiskiy.pdf</ref> ==

Пусть <math> W = w_{ij} \in[0,1],\; i = 1, ..., M, \; j = 1, ..., c</math> - матрица разбиения, где <math>w_{i,j}</math> - степень принадлежности объекта <math>i</math> к кластеру <math>j</math>; <math>c</math> - количество кластеров, <math>M</math> - количество векторов.

При этом элементы матрицы должны удовлетворять условиям:

* <math>\sum_{j = 1}^c w_{ij} = 1, i = 1, ..., M</math> <math>(1)</math>
* <math>0 < \sum_{i = 1}^M w_{ij} < M, j = 1, ..., c</math> <math>(2)</math>

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

1) Задаем параметры алгоритма: <math>c</math> - количество кластеров; <math>m >= 1</math> - экспоненциальный вес, определяющий нечеткость кластеров; <math>\varepsilon > 0</math> - параметр останова алгоритма.

2) Генерируем случайным образом матрицу нечеткого разбиения с учетом условий <math>(1)</math> и <math>(2)</math>

3) Рассчитываем центроиды (центры кластеров): <math>V_j = {{\sum_{i=1}^M w_{ij}^m * X_i} \over {\sum_{i=1}^M w_{ij}^m}}, j = 1, ..., c</math>

4) Рассчитываем расстояния между объектами <math>X</math> и центроидами:

<math>D_{ij} = {||X_i - V_j||}, i = 1,...,M; j = 1,...,c </math>

5) Пересчет элементов матрицы разбиения:

при <math>D_{ij} >0</math> : <math>w_{ij} = {{1}\over {{ (\sum_{k=1}^c {{D_{ij}}\over{D_{ik}}} ) }^{2/(m-1)}}}, j = 1,...,c</math>

при <math>D_{ij} =0</math> : <math>w_{ij} = \delta_{ij}, j = 1,...,c</math>, где <math>\delta_{ij}</math> - символ Кронекера

6) Если <math>|| F - F^{*} || < \varepsilon </math>, где <math>F^{*}</math> - матрица нечеткого разбиения предыдущей итерации, то идем далее, иначе возвращаемся на пункт 3.

7) Конец.

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

Вычислительным ядром алгоритма являются пункты (3), (4), (5) - расчет центроидов, вычисление расстояний и пересчет элементов матрицы соответственно

== Макроструктура алгоритма ==
Основные шаги при реализации алгоритма
* Генерация случайной матрицы размера <math>M</math> на где <math>c</math>, проверка условий
* Расчет центроидов – по сути, скалярное произведение с нормировкой
* Расчет расстояний – в общепринятом случае является скалярным произведением
* Пересчет матрицы – по сути, скалярное произведение
* Проверка условий останова – вычисление нормы

== Схема реализации последовательного алгоритма ==
float ** FuzzyCMeans (float** X, c, m, eps){
n = X.size();
r = X[0].size();
centers = generateZeroFill(c, r)
Wprev = genetateRandFill(n, c);
W = Wprev;
while (true){
// обновляем центры кластеров
for (int i=0; i<c; i++){
float * num = new float []();
float den = 0;
for (int j=0; j<n; j++){
num += pow(W[j][i], m) * X[j];
den+=pow(W[j][i], m);
}
centers[i] = num / den;
}
//обновляем вероятности W и считаем расстояние между матрицами W и Wprev
float max_diff = 0;
for (int i=0; i<n; i++)
for (int j=0; j<c; j++){
total = 0;
for (int m=0; m<с; m++)
total += pow(distance(X[i], centers[j]) / distance(X[i], centers[m]), 2/(m-1));
W[i][j] = 1/total;
max_diff = max(abs(Wprev[i][j]-W[i][j]), max_diff);
Wprev[i][j] = W[i][j];
}
if (max_diff < eps):
break;
}
return W;
}

== Последовательная сложность алгоритма ==
Последовательная сложность алгоритма состоит из сложности каждой итерации умноженной на их количество. Так как число итераций заранее неизвестно и зависит от входных параметров, рассмотрим сложность на каждой итерации. Наибольшую сложность представляет собой пересчет матрицы, сложность которого <math>O(c^2 nd)</math> (по сравнению со сложностью <math>O(cnd)</math> расчета расстояний, вычисления центроидов и проверки условия останова). Итого общая сложность алгоритма <math>O(c^2 ndi)</math>

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

'''Первый ярус''' состоит из <math>M</math> параллельных операций 1, 2, совершаемых в цикле <math>c</math> раз для каждого кластера.

'''Операция 1''': <math>w_{ij}^m</math>, где <math>j</math> - номер итерации в цикле, <math>i</math> - номер параллельной ветви.

'''Операция 2''': <math>w_{ij}^m*X_i</math>

Здесь <math>j</math> - номер итерации в цикле, <math>i</math> - номер параллельной ветви.

На выходе из каждой ветки получаем вектор размера <math>1</math> x <math>c</math> и матрицу размера <math>d</math> x <math>c</math>.
Далее совершаем поэлементное сложение векторов и матриц соответственно, а затем делим каждый столбец в матрице на соответствующий элемент в векторе.

'''Второй ярус''' состоит их <math>M</math> параллельных операций 3, 4, 5 также совершаемых в цикле <math>c</math> раз.

'''Операция 4''': обновление значения <math>w_{ij}</math> по указанной в разделе 1.2 в пункте 5 формуле.

'''Операция 5''': <math>maximum = max(|w_{ij} - w_{ij}^{prev}|, maximum)</math>.

'''Операция 6''': <math>w_{ij}^{prev} = w_{ij}</math>.

Здесь <math>j</math> - номер итерации в цикле, <math>i</math> - номер параллельной ветви.

На выходе из каждой ветки получаем число <math>maximum</math>. Далее находим максимальное значение из полученных величин для каждой ветки. Затем проверяем условие останова алгоритма.

[[File:Scheme.JPG]]

== Ресурс параллелизма алгоритма ==
Параллельная сложность алгоритма: <math>M*c^2*i</math>. Такая сложность получается за счет распараллеливания на каждом ярусе <math>M</math> операций. Иерархическая структура параллелизма подробно описана в [[#Информационный граф|п.1.7]].

В алгоритме не возникает скошенного параллелизма.

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

* Входные данные алгоритма: набор векторов <math>x_i</math> размерности <math>d</math>, где <math>i = 1,...,M</math>; <math>M</math> - количество векторов.
* Выходные данные алгоритма: матрица вероятностей принадлежности векторов кластерам <math>M</math> на <math>c</math>.

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

* Соотношение последовательной и параллельной формы алгоритма: <math>M</math>
* Вычислительная мощность: <math>{dc^2i} \over {c+d}</math>.
* Устойчивость: алгоритм не является устойчивым, поэтому существует много исследований о том, как первоначально выбрать параметры кластеризации.
* Сбалансированность: в данном алгоритме операция умножения доминирует над операцией сложения. Операции между параллельными ветвями сбалансированны.
* Детерминированность: алгоритм не является детерминированным, так как матрица нечеткого разбиение генерируется произвольно.
* Степень исхода вершины информационного графа ( для одной интерации): 2 (3 - с учетом, если выходные данные пошли на следующую итерацию).

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

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

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

* Реализация алгоритма на POSTGRESQL: http://num-meth.srcc.msu.ru/zhurnal/tom_2012/pdf/v13r207.pdf
* Библиотека для MATLAB: http://www.mathworks.com/help/fuzzy/fcm.html (распространяется на коммерческой основе)

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

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

2016-10-15T12:32:08Z

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

{{algorithm
| name = Нечеткий алгоритм C средних
| serial_complexity = <math>O(Mdc^2i)</math>, <math>i</math> - количество итераций
| input_data = <math>M*d</math>, [количество наблюдений * размерность]
| output_data = <math>M*c</math>, [количество наблюдений * количество кластеров]
| pf_height = <math>2i</math>
| pf_width = <math>n</math>
}}

Авторы : [[Участник:Gkhazeeva|Гелана Хазеева]], [[Участник:Yushin|Павел Юшин]]

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

== Общее описание алгоритма ==
Кластеризация - это объединение объектов в группы (кластеры) на основе схожести признаков для объектов одной группы и отличий между группами. Нечеткий алгоритм C Средних (Fuzzy C-means, FCM) - алгоритм кластеризации, позволяющий объектам принадлежать с различной степенью нескольким кластерам одновременно. Впервые алгоритм был предложен J.C. Dunn в 1973 <ref>{{Cite journal|last=Dunn|first=J. C.|date=1973-01-01|title=A Fuzzy Relative of the ISODATA Process and Its Use in Detecting Compact Well-Separated Clusters|url=http://dx.doi.org/10.1080/01969727308546046|journal=Journal of Cybernetics|volume=3|issue=3|pages=32–57|doi=10.1080/01969727308546046|issn=0022-0280}}</ref>. Нечеткое разбиение позволяет просто решить проблему объектов, расположенных на границе двух кластеров - им назначают степени принадлежностей равные 0.5.

Входные данные алгоритма: набор векторов, которые следует кластеризовать.

Параметры алгоритма: <math>c</math> - количество кластеров; <math>m</math> - экспоненциальный вес; <math>\varepsilon</math> - параметр останова алгоритма.

Выходные данные: матрица вероятностей принадлежности векторов кластерам.

Краткое описание алгоритма:

* Задать параметры алгоритма.

* Сгенерировать случайную матрицу принадлежностей векторов кластерам (матрицу нечеткого разбиения).

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

== Математическое описание алгоритма <ref>http://it-claim.ru/Persons/Neyskiy/Article2_Neiskiy.pdf</ref> ==

Пусть <math> W = w_{ij} \in[0,1],\; i = 1, ..., M, \; j = 1, ..., c</math> - матрица разбиения, где <math>w_{i,j}</math> - степень принадлежности объекта <math>i</math> к кластеру <math>j</math>; <math>c</math> - количество кластеров, <math>M</math> - количество векторов.

При этом элементы матрицы должны удовлетворять условиям:

* <math>\sum_{j = 1}^c w_{ij} = 1, i = 1, ..., M</math> <math>(1)</math>
* <math>0 < \sum_{i = 1}^M w_{ij} < M, j = 1, ..., c</math> <math>(2)</math>

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

1) Задаем параметры алгоритма: <math>c</math> - количество кластеров; <math>m >= 1</math> - экспоненциальный вес, определяющий нечеткость кластеров; <math>\varepsilon > 0</math> - параметр останова алгоритма.

2) Генерируем случайным образом матрицу нечеткого разбиения с учетом условий <math>(1)</math> и <math>(2)</math>

3) Рассчитываем центроиды (центры кластеров): <math>V_j = {{\sum_{i=1}^M w_{ij}^m * X_i} \over {\sum_{i=1}^M w_{ij}^m}}, j = 1, ..., c</math>

4) Рассчитываем расстояния между объектами <math>X</math> и центроидами:

<math>D_{ij} = {||X_i - V_j||}, i = 1,...,M; j = 1,...,c </math>

5) Пересчет элементов матрицы разбиения:

при <math>D_{ij} >0</math> : <math>w_{ij} = {{1}\over {{ (\sum_{k=1}^c {{D_{ij}}\over{D_{ik}}} ) }^{2/(m-1)}}}, j = 1,...,c</math>

при <math>D_{ij} =0</math> : <math>w_{ij} = \delta_{ij}, j = 1,...,c</math>, где <math>\delta_{ij}</math> - символ Кронекера

6) Если <math>|| F - F^{*} || < \varepsilon </math>, где <math>F^{*}</math> - матрица нечеткого разбиения предыдущей итерации, то идем далее, иначе возвращаемся на пункт 3.

7) Конец.

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

Вычислительным ядром алгоритма являются пункты (3), (4), (5) - расчет центроидов, вычисление расстояний и пересчет элементов матрицы соответственно

== Макроструктура алгоритма ==
Основные шаги при реализации алгоритма
* Генерация случайной матрицы размера <math>M</math> на где <math>c</math>, проверка условий
* Расчет центроидов – по сути, скалярное произведение с нормировкой
* Расчет расстояний – в общепринятом случае является скалярным произведением
* Пересчет матрицы – по сути, скалярное произведение
* Проверка условий останова – вычисление нормы

== Схема реализации последовательного алгоритма ==
float ** FuzzyCMeans (float** X, c, m, eps){
n = X.size();
r = X[0].size();
centers = generateZeroFill(c, r)
Wprev = genetateRandFill(n, c);
W = Wprev;
while (true){
// обновляем центры кластеров
for (int i=0; i<c; i++){
float * num = new float []();
float den = 0;
for (int j=0; j<n; j++){
num += pow(W[j][i], m) * X[j];
den+=pow(W[j][i], m);
}
centers[i] = num / den;
}
//обновляем вероятности W и считаем расстояние между матрицами W и Wprev
float max_diff = 0;
for (int i=0; i<n; i++)
for (int j=0; j<c; j++){
total = 0;
for (int m=0; m<с; m++)
total += pow(distance(X[i], centers[j]) / distance(X[i], centers[m]), 2/(m-1));
W[i][j] = 1/total;
max_diff = max(abs(Wprev[i][j]-W[i][j]), max_diff);
Wprev[i][j] = W[i][j];
}
if (max_diff < eps):
break;
}
return W;
}

== Последовательная сложность алгоритма ==
Последовательная сложность алгоритма состоит из сложности каждой итерации умноженной на их количество. Так как число итераций заранее неизвестно и зависит от входных параметров, рассмотрим сложность на каждой итерации. Наибольшую сложность представляет собой пересчет матрицы, сложность которого <math>O(c^2 nd)</math> (по сравнению со сложностью <math>O(cnd)</math> расчета расстояний, вычисления центроидов и проверки условия останова). Итого общая сложность алгоритма <math>O(c^2 ndi)</math>

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

'''Первый ярус''' состоит из <math>M</math> параллельных операций 1, 2, совершаемых в цикле <math>c</math> раз для каждого кластера.

'''Операция 1''': <math>w_{ij}^m</math>, где <math>j</math> - номер итерации в цикле, <math>i</math> - номер параллельной ветви.

'''Операция 2''': <math>w_{ij}^m*X_i</math>

Здесь <math>j</math> - номер итерации в цикле, <math>i</math> - номер параллельной ветви.

На выходе из каждой ветки получаем вектор размера <math>1</math> x <math>c</math> и матрицу размера <math>d</math> x <math>c</math>.
Далее совершаем поэлементное сложение векторов и матриц соответственно, а затем делим каждый столбец в матрице на соответствующий элемент в векторе.

'''Второй ярус''' состоит их <math>M</math> параллельных операций 3, 4, 5 также совершаемых в цикле <math>c</math> раз.

'''Операция 4''': обновление значения <math>w_{ij}</math> по указанной в разделе 1.2 в пункте 5 формуле.

'''Операция 5''': <math>maximum = max(|w_{ij} - w_{ij}^{prev}|, maximum)</math>.

'''Операция 6''': <math>w_{ij}^{prev} = w_{ij}</math>.

Здесь <math>j</math> - номер итерации в цикле, <math>i</math> - номер параллельной ветви.

На выходе из каждой ветки получаем число <math>maximum</math>. Далее находим максимальное значение из полученных величин для каждой ветки. Затем проверяем условие останова алгоритма.

[[File:Scheme.JPG]]

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

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

* Входные данные алгоритма: набор векторов <math>x_i</math> размерности <math>d</math>, где <math>i = 1,...,M</math>; <math>M</math> - количество векторов.
* Выходные данные алгоритма: матрица вероятностей принадлежности векторов кластерам <math>M</math> на <math>c</math>.

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

* Соотношение последовательной и параллельной формы алгоритма: <math>M</math>
* Вычислительная мощность: <math>{dc^2i} \over {c+d}</math>.
* Устойчивость: алгоритм не является устойчивым, поэтому существует много исследований о том, как первоначально выбрать параметры кластеризации.
* Сбалансированность: в данном алгоритме операция умножения доминирует над операцией сложения. Операции между параллельными ветвями сбалансированны.
* Детерминированность: алгоритм не является детерминированным, так как матрица нечеткого разбиение генерируется произвольно.
* Степень исхода вершины информационного графа ( для одной интерации): 2 (3 - с учетом, если выходные данные пошли на следующую итерацию).

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

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

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

* Реализация алгоритма на POSTGRESQL: http://num-meth.srcc.msu.ru/zhurnal/tom_2012/pdf/v13r207.pdf
* Библиотека для MATLAB: http://www.mathworks.com/help/fuzzy/fcm.html (распространяется на коммерческой основе)

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

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

2016-10-15T12:21:13Z

Yushin:

{{algorithm
| name = Нечеткий алгоритм C средних
| serial_complexity = <math>O(Mdc^2i)</math>, <math>i</math> - количество итераций
| input_data = <math>M*d</math>, [количество наблюдений * размерность]
| output_data = <math>M*c</math>, [количество наблюдений * количество кластеров]
| pf_height = <math>2i</math>
| pf_width = <math>n</math>
}}

Авторы : [[Участник:Gkhazeeva|Гелана Хазеева]], [[Участник:Yushin|Павел Юшин]]

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

== Общее описание алгоритма ==
Кластеризация - это объединение объектов в группы (кластеры) на основе схожести признаков для объектов одной группы и отличий между группами. Нечеткий алгоритм C Средних (Fuzzy C-means, FCM) - алгоритм кластеризации, позволяющий объектам принадлежать с различной степенью нескольким кластерам одновременно. Впервые алгоритм был предложен J.C. Dunn в 1973 <ref>{{Cite journal|last=Dunn|first=J. C.|date=1973-01-01|title=A Fuzzy Relative of the ISODATA Process and Its Use in Detecting Compact Well-Separated Clusters|url=http://dx.doi.org/10.1080/01969727308546046|journal=Journal of Cybernetics|volume=3|issue=3|pages=32–57|doi=10.1080/01969727308546046|issn=0022-0280}}</ref>. Нечеткое разбиение позволяет просто решить проблему объектов, расположенных на границе двух кластеров - им назначают степени принадлежностей равные 0.5.

Входные данные алгоритма: набор векторов, которые следует кластеризовать.

Параметры алгоритма: <math>c</math> - количество кластеров; <math>m</math> - экспоненциальный вес; <math>\varepsilon</math> - параметр останова алгоритма.

Выходные данные: матрица вероятностей принадлежности векторов кластерам.

Краткое описание алгоритма:

* Задать параметры алгоритма.

* Сгенерировать случайную матрицу принадлежностей векторов кластерам (матрицу нечеткого разбиения).

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

== Математическое описание алгоритма <ref>http://it-claim.ru/Persons/Neyskiy/Article2_Neiskiy.pdf</ref> ==

Пусть <math> W = w_{ij} \in[0,1],\; i = 1, ..., M, \; j = 1, ..., c</math> - матрица разбиения, где <math>w_{i,j}</math> - степень принадлежности объекта <math>i</math> к кластеру <math>j</math>; <math>c</math> - количество кластеров, <math>M</math> - количество векторов.

При этом элементы матрицы должны удовлетворять условиям:

* <math>\sum_{j = 1}^c w_{ij} = 1, i = 1, ..., M</math> <math>(1)</math>
* <math>0 < \sum_{i = 1}^M w_{ij} < M, j = 1, ..., c</math> <math>(2)</math>

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

1) Задаем параметры алгоритма: <math>c</math> - количество кластеров; <math>m >= 1</math> - экспоненциальный вес, определяющий нечеткость кластеров; <math>\varepsilon > 0</math> - параметр останова алгоритма.

2) Генерируем случайным образом матрицу нечеткого разбиения с учетом условий <math>(1)</math> и <math>(2)</math>

3) Рассчитываем центроиды (центры кластеров): <math>V_j = {{\sum_{i=1}^M w_{ij}^m * X_i} \over {\sum_{i=1}^M w_{ij}^m}}, j = 1, ..., c</math>

4) Рассчитываем расстояния между объектами <math>X</math> и центроидами:

<math>D_{ij} = {||X_i - V_j||}, i = 1,...,M; j = 1,...,c </math>

5) Пересчет элементов матрицы разбиения:

при <math>D_{ij} >0</math> : <math>w_{ij} = {{1}\over {{ (\sum_{k=1}^c {{D_{ij}}\over{D_{ik}}} ) }^{2/(m-1)}}}, j = 1,...,c</math>

при <math>D_{ij} =0</math> : <math>w_{ij} = \delta_{ij}, j = 1,...,c</math>, где <math>\delta_{ij}</math> - символ Кронекера

6) Если <math>|| F - F^{*} || < \varepsilon </math>, где <math>F^{*}</math> - матрица нечеткого разбиения предыдущей итерации, то идем далее, иначе возвращаемся на пункт 3.

7) Конец.

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

Вычислительным ядром алгоритма являются пункты (3), (4), (5) - расчет центроидов, вычисление расстояний и пересчет элементов матрицы соответственно

== Макроструктура алгоритма ==
Основные шаги при реализации алгоритма
* Генерация случайной матрицы размера <math>M</math> на где <math>c</math>, проверка условий
* Расчет центроидов – по сути, скалярное произведение с нормировкой
* Расчет расстояний – в общепринятом случае является скалярным произведением
* Пересчет матрицы – по сути, скалярное произведение
* Проверка условий останова – вычисление нормы

== Схема реализации последовательного алгоритма ==
float ** FuzzyCMeans (float** X, c, m, eps){
n = X.size();
r = X[0].size();
centers = generateZeroFill(c, r)
Wprev = genetateRandFill(n, c);
W = Wprev;
while (true){
// обновляем центры кластеров
for (int i=0; i<c; i++){
float * num = new float []();
float den = 0;
for (int j=0; j<n; j++){
num += pow(W[j][i], m) * X[j];
den+=pow(W[j][i], m);
}
centers[i] = num / den;
}
//обновляем вероятности W и считаем расстояние между матрицами W и Wprev
float max_diff = 0;
for (int i=0; i<n; i++)
for (int j=0; j<c; j++){
total = 0;
for (int m=0; m<с; m++)
total += pow(distance(X[i], centers[j]) / distance(X[i], centers[m]), 2/(m-1));
W[i][j] = 1/total;
max_diff = max(abs(Wprev[i][j]-W[i][j]), max_diff);
Wprev[i][j] = W[i][j];
}
if (max_diff < eps):
break;
}
return W;
}

== Последовательная сложность алгоритма ==
Последовательная сложность алгоритма состоит из сложности каждой итерации умноженной на их количество. Так как число итераций заранее неизвестно и зависит от входных параметров, рассмотрим сложность на каждой итерации. Наибольшую сложность представляет собой пересчет матрицы, сложность которого <math>O(c^2 nd)</math> (по сравнению со сложностью <math>O(cnd)</math> расчета расстояний, вычисления центроидов и проверки условия останова). Итого общая сложность алгоритма <math>O(c^2 ndi)</math>

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

'''Первый ярус''' состоит из <math>M</math> параллельных операций 1, 2, совершаемых в цикле <math>c</math> раз для каждого кластера.

'''Операция 1''': <math>w_{ij}^m</math>, где <math>j</math> - номер итерации в цикле, <math>i</math> - номер параллельной ветви.

'''Операция 2''': <math>w_{ij}^m*X_i</math>

Здесь <math>j</math> - номер итерации в цикле, <math>i</math> - номер параллельной ветви.

На выходе из каждой ветки получаем вектор размера <math>1</math> x <math>c</math> и матрицу размера <math>d</math> x <math>c</math>.
Далее совершаем поэлементное сложение векторов и матриц соответственно, а затем делим каждый столбец в матрице на соответствующий элемент в векторе.

'''Второй ярус''' состоит их <math>M</math> параллельных операций 3, 4, 5 также совершаемых в цикле <math>c</math> раз.

'''Операция 4''': обновление значения <math>w_{ij}</math> по указанной в разделе 1.2 в пункте 5 формуле.

'''Операция 5''': <math>maximum = max(|w_{ij} - w_{ij}^{prev}|, maximum)</math>.

'''Операция 6''': <math>w_{ij}^{prev} = w_{ij}</math>.

Здесь <math>j</math> - номер итерации в цикле, <math>i</math> - номер параллельной ветви.

На выходе из каждой ветки получаем число <math>maximum</math>. Далее находим максимальное значение из полученных величин для каждой ветки. Затем проверяем условие останова алгоритма.

[[File:Scheme.JPG]]

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

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

* Входные данные алгоритма: набор векторов <math>x_i</math> размерности <math>d</math>, где <math>i = 1,...,M</math>; <math>M</math> - количество векторов.
* Выходные данные алгоритма: матрица вероятностей принадлежности векторов кластерам <math>M</math> на <math>c</math>.

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

* Соотношение последовательной и параллельной формы алгоритма: <math>n</math>
* Вычислительная мощность: <math>{dc^2i} \over {c+d}</math>.
* Устойчивость: алгоритм не является устойчивым, поэтому существует много исследований о том, как первоначально выбрать параметры кластеризации.
* Сбалансированность: в данном алгоритме операция умножения доминирует над операцией сложения. Операции между параллельными ветвями сбалансированны.
* Детерминированность: алгоритм не является детерминированным, так как матрица нечеткого разбиение генерируется произвольно.
* Степень исхода вершины информационного графа ( для одной интерации): 2 (3 - с учетом, если выходные данные пошли на следующую итерацию).

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

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

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

* Реализация алгоритма на POSTGRESQL: http://num-meth.srcc.msu.ru/zhurnal/tom_2012/pdf/v13r207.pdf
* Библиотека для MATLAB: http://www.mathworks.com/help/fuzzy/fcm.html (распространяется на коммерческой основе)

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

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

2016-10-15T12:00:33Z

Yushin:

== Перенос ==
Статья: [[Участники: Бобошко А., Юмакаева А./Решение начальной задачи Коши для системы ОДУ методом Рунге-Кутта 4-го порядка]];
Выполняют: Бобошко Алексей и Юмакаева Алина

Статья: [[Алгоритм кластеризации, основанный на сетях Кохоннена]];
Выполняют: Логвиненко Александра и Адиев Тохтар

Статья: [[Ортогонализация Грама-Шмидта]];
Выполняют: [[Участник:KibAndrey| Кибанов Андрей]] и Аджиева Татьяна

Статья: [[Самоорганизующиеся карты Кохонена]];
Выполняет: [[Участник:Anton goy| Гой Антон]]

Статья:[[ЕМ-алгоритм_(Тематическое_моделирование)]];
Выполняют: Мурат Апишев и Андрей Заночкин

Статья:[[Алгоритм_Ланцоша_с_полной_переортогонализацией]];
Выполняет:[[Участник:Sfedotov| Федотов С.А.]]

Статья: [[Алгоритм_k-средних]]
Выполняют: [[Участник:Error2407|Богомазов Евгений]], [[Участник:Илья_Егоров|Егоров Илья]]

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

Статья: [[Решение_задачи_Коши_для_системы_ОДУ_методом_Рунге-Кутты_4_порядка]];
Выполняют: [[Участник:Алимов_Дамир_Алиевич|Алимов Дамир]] и [[Участник:Anlesnichiy|Антон Лесничий]]

Статья: [[Строгий_алгоритм_С_средних_(Hard_C-Means,_HCM)]];
Выполняют: [[Участник:Светлана_Лукьяненко|Лукьяненко Светлана]] и [[Участник:Юрий_Комаров|Комаров Юрий]]

Статья: [[Алгоритм кластеризации, основанный на минимальном остовном дереве]];
Выполняет: [[Участник:Astandrik | Стандрик Антон Сергеевич]]

Статья: [[Умножение разреженной матрицы на вектор]];
Выполняет: [[Участник:Lexaloris | Новоселов Алексей]], Выполняет: [[Участник:pahom | Кочетков Павел]]

Статья: [[Нахождение_собственных_чисел_квадратной_матрицы_методом_QR_разложения_(3)|Нахождение собственных чисел квадратной матрицы методом QR разложения (3)]];
Выполняют: [[Участник:Смирнова_Александра|Смирнова А.С.]], [[Участник:Александра_Киямова|Киямова А.]]

Статья: [[Метод_Якоби_вычисления_сингулярных_чисел_и_векторов]];
Выполняют: [[Участница:Почернина_Елена| Почернина Елена]] и [[Участница:Светлана|Костюкова Светлана]]

Статья: [[Метод_Ньютона_для_решения_систем_нелинейных_уравнений(2)]];
Выполняют: [[Участник:Oleggium|Гирняк О.Р.]], [[Участник:Dimx19|Васильков Д.А.]]

Статья: [[Алгоритм_кластеризации_с_использованием_представлений]];
Выполняют: [[Участник:Cookie|Шатков С.А.]], [[Антохина Ю.А.]]

Статья: [[Быстрое_преобразование_Фурье_(FFT)|Быстрое преобразование Фурье (FFT)]];
Выполняют: [[Участник:Victoria_Stepanischeva|Степанищева Виктория]] и [[Участник:Igor_Munkin|Мунькин Игорь]]

Статья: [[Быстрое_дискретное_преобразование_Фурье|Быстрое_дискретное_преобразование_Фурье]];
Выполняют: [[Участник:ivanov.kir.m | К.М.Иванов]], [[Участник:Pumpkin | А.C.Сапин]]

Статья:[[Алгоритм_k_средних]]
Выполняют: [[Участник:Parkhomenko|Пархоменко Павел]], [[Участник:ivan.mashonskiy|Машонский Иван]]

Статья:[[EM-алгоритм_кластеризации]]
Выполняет: [[Участник:Noite|Зинченко Дмитрий]]

Статья:[[Алгоритм_k_means]]
Выполняют: [[Участник:IanaV| Валуйская Яна]], [[Глотов Евгений]]

Статья: [[Метод Якоби вычисления собственных значений симметричной матрицы ЗП |Метод Якоби вычисления собственных значений симметричной матрицы ЗП]];
Выполняют: [[Участник:Зиновьев Владимир|Зиновьев В.С.]], [[Участник:Пронин Андрей|Пронин А.М.]]

Статья:[[Алгоритм_кластеризации,_основанный_на_минимальном_покрывающем_дереве]]
Выполняет: [[Участник:Kanast74|Дмитриева Анастасия]]

Статья:[[Нахождение_собственных_чисел_квадратной_матрицы_методом_QR_разложения_(4)]]
Выполняют: [[Участник:F-morozov|Морозов Ф. В.]], [[Участник:Nataliya|Пащенко Н. Ф.]]

Статья:[[Хранение_ненулевых_элементов_разреженных_матриц._Умножение_разреженной_матрицы_на_вектор]];
Выполняют: [[Участник:Trrufina|Третьякова Р.М.]] и [[Участник:Екатерина_Буторина|Буторина Е.В.]]

Статья: [[Алгоритм_кластеризации_с_использованием_представлений2]];
Выполняет: [[Участник:Лукьянова Анна|Лукьянова А.Я.]]

Статья: [[Метод Якоби вычисления собственных значений симметричной матрицы]];
Выполняют: [[Участник: Galkina|Галкина А.С.]], [[Участник: Игорь|Плахов И.А.]]

Статья: [[Метод рекурсивной координатной бисекции]];
Выполняют: [[Участник: Obirvalger|Гордеев Михаил]], [[Участник: KolmakovEA|Колмаков Евгений]]

Статья: [[Итерационный метод решения системы линейных алгебраических уравнений GMRES (обобщенный метод минимальных невязок)]];
Выполняют: [[Участник: Эльвира Ахиярова|Ахиярова Эльвира]]

Статья: [[Хранение ненулевых элементов разреженной матрицы. Умножение разреженной матрицы на вектор]];
Выполняют: [[Участник: Janyell|Сычева Евгения]], [[Участник: Ahahalin|Хахалин Анатолий]]

Статья: [[Построение матрицы Адамара произвольного размера]];
Выполняют: [[Участник: Бугаков Юрий|Бугаков Юрий]], Кужамалиев Ернур

Статья: [[Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки (1)]]
Выполняют: [[Участница:Sannikovats| Санникова Татьяна Сергеевна]], [[Участник:Plukshin| Лукшин Петр Андреевич]]

Статья: [[Алгоритм кластеризации, основанный на построении каркаса]];
Выполняют: [[Участник:SenderovichNikita| Сендерович Никита]]

Статья: [[Алгоритм кластеризации, основанный на максимизации ожидания]];
Выполняют: Готман Мария, Лукашкина Юлия

Статья: [[Partitioning_Around_Medoids_(PAM)]]
Выполняют: [[Участник:Avasilenko|А.Э.Василенко]], [[Участник:Anastasia|А.В.Тузикова]]

Статья: [[Нечеткий алгоритм С-средних (Fuzzy C-means)]]
Выполняют: [[Участник:Nikmedoed|Н.А. Муромцев]], [[Участник:illusive_mike|М.С. Дворецкий]]

Статья: [[Нечеткий алгоритм C средних]]
Выполняют: [[Участник:Gkhazeeva|Гелана Хазеева]], [[Участник:Yushin|Павел Юшин]]

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

2016-10-14T17:59:48Z

Yushin:

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

2016-10-14T17:55:32Z

Yushin:

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

2016-10-14T17:35:03Z

Yushin:

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

2016-10-14T17:06:30Z

Yushin:

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

2016-10-14T17:05:24Z

Yushin:

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

2016-10-14T17:05:07Z

Yushin:

{{algorithm
| name = Нечеткий алгоритм C средних
| serial_complexity = <math>O(ndc^2i)</math>, <math>i</math> - количество итераций
| input_data = <math>n*d</math>, [количество наблюдений * размерность]
| output_data = <math>n*c</math>, [количество наблюдений * количество кластеров]
| pf_height = <math></math>
| pf_width = <math></math>
}}

Авторы : [[Участник:Gkhazeeva|Гелана Хазеева]], [[Участник:Yushin|Павел Юшин]]

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

== Общее описание алгоритма ==
Кластеризация - это объединение объектов в группы (кластеры) на основе схожести признаков для объектов одной группы и отличий между группами. Нечеткий алгоритм C Средних (Fuzzy C-means, FCM) - алгоритм кластеризации, позволяющий объектам принадлежать с различной степенью нескольким кластерам одновременно. Впервые алгоритм был предложен J.C. Dunn в 1973 <ref>{{Cite journal|last=Dunn|first=J. C.|date=1973-01-01|title=A Fuzzy Relative of the ISODATA Process and Its Use in Detecting Compact Well-Separated Clusters|url=http://dx.doi.org/10.1080/01969727308546046|journal=Journal of Cybernetics|volume=3|issue=3|pages=32–57|doi=10.1080/01969727308546046|issn=0022-0280}}</ref>. Нечеткое разбиение позволяет просто решить проблему объектов, расположенных на границе двух кластеров - им назначают степени принадлежностей равные 0.5.

Входные данные алгоритма: набор векторов, которые следует кластеризовать.

Параметры алгоритма: <math>c</math> - количество кластеров; <math>m</math> - экспоненциальный вес; <math>\varepsilon</math> - параметр останова алгоритма.

Выходные данные: матрица вероятностей принадлежности векторов кластерам.

Краткое описание алгоритма:

* Задать параметры алгоритма.

* Сгенерировать случайную матрицу принадлежностей векторов кластерам (матрицу нечеткого разбиения).

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

== Математическое описание алгоритма <ref>http://it-claim.ru/Persons/Neyskiy/Article2_Neiskiy.pdf</ref> ==

Пусть <math> W = w_{ij} \in[0,1],\; i = 1, ..., M, \; j = 1, ..., c</math> - матрица разбиения, где <math>w_{i,j}</math> - степень принадлежности объекта <math>i</math> к кластеру <math>j</math>; <math>c</math> - количество кластеров, <math>M</math> - количество векторов.

При этом элементы матрицы должны удовлетворять условиям:

* <math>\sum_{j = 1}^c w_{ij} = 1, i = 1, ..., M</math> <math>(1)</math>
* <math>0 < \sum_{i = 1}^M w_{ij} < M, j = 1, ..., c</math> <math>(2)</math>

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

1) Задаем параметры алгоритма: <math>c</math> - количество кластеров; <math>m >= 1</math> - экспоненциальный вес, определяющий нечеткость кластеров; <math>\varepsilon > 0</math> - параметр останова алгоритма.

2) Генерируем случайным образом матрицу нечеткого разбиения с учетом условий <math>(1)</math> и <math>(2)</math>

3) Рассчитываем центроиды (центры кластеров): <math>V_j = {{\sum_{i=1}^M w_{ij}^m * X_i} \over {\sum_{i=1}^M w_{ij}^m}}, j = 1, ..., c</math>

4) Рассчитываем расстояния между объектами <math>X</math> и центроидами:

<math>D_{ij} = {||X_i - V_j||}, i = 1,...,M; j = 1,...,c </math>

5) Пересчет элементов матрицы разбиения:

при <math>D_{ij} >0</math> : <math>w_{ij} = {{1}\over {{ (\sum_{k=1}^c {{D_{ij}}\over{D_{ik}}} ) }^{2/(m-1)}}}, j = 1,...,c</math>

при <math>D_{ij} =0</math> : <math>w_{ij} = \delta_{ij}, j = 1,...,c</math>, где <math>\delta_{ij}</math> - символ Кронекера

6) Если <math>|| F - F^{*} || < \varepsilon </math>, где <math>F^{*}</math> - матрица нечеткого разбиения предыдущей итерации, то идем далее, иначе возвращаемся на пункт 3.

7) Конец.

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

Вычислительным ядром алгоритма являются пункты (3), (4), (5) - расчет центроидов, вычисление расстояний и пересчет элементов матрицы соответственно

== Макроструктура алгоритма ==
Основные шаги при реализации алгоритма
* Генерация случайной матрицы размера <math>M</math> на где <math>c</math>, проверка условий
* Расчет центроидов – по сути, скалярное произведение с нормировкой
* Расчет расстояний – в общепринятом случае является скалярным произведением
* Пересчет матрицы – по сути, скалярное произведение
* Проверка условий останова – вычисление нормы

== Схема реализации последовательного алгоритма ==
float ** FuzzyCMeans (float** X, c, m, eps){
n = X.size();
r = X[0].size();
centers = generateZeroFill(c, r)
Wprev = genetateRandFill(n, c);
W = Wprev;
while (true){
// обновляем центры кластеров
for (int i=0; i<c; i++){
float * num = new float []();
float den = 0;
for (int j=0; j<n; j++){
num += pow(W[j][i], m) * X[j];
den+=pow(W[j][i], m);
}
centers[i] = num / den;
}
//обновляем вероятности W и считаем расстояние между матрицами W и Wprev
float max_diff = 0;
for (int i=0; i<n; i++)
for (int j=0; j<c; j++){
total = 0;
for (int m=0; m<с; m++)
total += pow(distance(X[i], centers[j]) / distance(X[i], centers[m]), 2/(m-1));
W[i][j] = 1/total;
max_diff = max(abs(Wprev[i][j]-W[i][j]), max_diff);
Wprev[i][j] = W[i][j];
}
if (max_diff < eps):
break;
}
return W;
}

== Последовательная сложность алгоритма ==
Последовательная сложность алгоритма состоит из сложности каждой итерации умноженной на их количество. Так как число итераций заранее неизвестно и зависит от входных параметров, рассмотрим сложность на каждой итерации. Наибольшую сложность представляет собой пересчет матрицы, сложность которого <math>O(c^2 nd)</math> (по сравнению со сложностью <math>O(cnd)</math> расчета расстояний, вычисления центроидов и проверки условия останова). Итого общая сложность алгоритма <math>O(c^2 ndi)</math>

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

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

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

* Входные данные алгоритма: набор векторов <math>x_i</math> размерности <math>d</math>, где <math>i = 1,...,M</math>; <math>M</math> - количество векторов.
* Выходные данные алгоритма: матрица размерности <math>M</math> на <math>c</math>.

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

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

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

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

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

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

2016-10-14T17:03:43Z

Yushin:

{{algorithm
| name = Нечеткий алгоритм C средних
| serial_complexity = <math>O(ndc^2i)</math>, <math>i</math> - количество итераций
| input_data = <math>n*d</math>, [количество наблюдений * размерность]
| output_data = <math>n*c</math>, [количество наблюдений * количество кластеров]
| pf_height = <math></math>
| pf_width = <math></math>
}}

Авторы : [[Участник:Gkhazeeva|Гелана Хазеева]], [[Участник:Yushin|Павел Юшин]]

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

== Общее описание алгоритма ==
Кластеризация - это объединение объектов в группы (кластеры) на основе схожести признаков для объектов одной группы и отличий между группами. Нечеткий алгоритм C Средних (Fuzzy C-means, FCM) - алгоритм кластеризации, позволяющий объектам принадлежать с различной степенью нескольким кластерам одновременно. Впервые алгоритм был предложен J.C. Dunn в 1973 <ref>{{Cite journal|last=Dunn|first=J. C.|date=1973-01-01|title=A Fuzzy Relative of the ISODATA Process and Its Use in Detecting Compact Well-Separated Clusters|url=http://dx.doi.org/10.1080/01969727308546046|journal=Journal of Cybernetics|volume=3|issue=3|pages=32–57|doi=10.1080/01969727308546046|issn=0022-0280}}</ref>. Нечеткое разбиение позволяет просто решить проблему объектов, расположенных на границе двух кластеров - им назначают степени принадлежностей равные 0.5.

Входные данные алгоритма: набор векторов, которые следует кластеризовать.

Параметры алгоритма: <math>c</math> - количество кластеров; <math>m</math> - экспоненциальный вес; <math>\varepsilon</math> - параметр останова алгоритма.

Выходные данные: матрица вероятностей принадлежности векторов кластерам.

Краткое описание алгоритма:

* Задать параметры алгоритма.

* Сгенерировать случайную матрицу принадлежностей векторов кластерам (матрицу нечеткого разбиения).

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

== Математическое описание алгоритма <ref>http://it-claim.ru/Persons/Neyskiy/Article2_Neiskiy.pdf</ref> ==

Пусть <math> W = w_{ij} \in[0,1],\; i = 1, ..., M, \; j = 1, ..., c</math> - матрица разбиения, где <math>w_{i,j}</math> - степень принадлежности объекта <math>i</math> к кластеру <math>j</math>; <math>c</math> - количество кластеров, <math>M</math> - количество векторов.

При этом элементы матрицы должны удовлетворять условиям:

* <math>\sum_{j = 1}^c w_{ij} = 1, i = 1, ..., M</math> <math>(1)</math>
* <math>0 < \sum_{i = 1}^M w_{ij} < M, j = 1, ..., c</math> <math>(2)</math>

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

1) Задаем параметры алгоритма: <math>c</math> - количество кластеров; <math>m >= 1</math> - экспоненциальный вес, определяющий нечеткость кластеров; <math>\varepsilon > 0</math> - параметр останова алгоритма.

2) Генерируем случайным образом матрицу нечеткого разбиения с учетом условий <math>(1)</math> и <math>(2)</math>

3) Рассчитываем центроиды (центры кластеров): <math>V_j = {{\sum_{i=1}^M w_{ij}^m * X_i} \over {\sum_{i=1}^M w_{ij}^m}}, j = 1, ..., c</math>

4) Рассчитываем расстояния между объектами <math>X</math> и центроидами:

<math>D_{ij} = {||X_i - V_j||}, i = 1,...,M; j = 1,...,c </math>

5) Пересчет элементов матрицы разбиения:

при <math>D_{ij} >0</math> : <math>w_{ij} = {{1}\over {{ (\sum_{k=1}^c {{D_{ij}}\over{D_{ik}}} ) }^{2/(m-1)}}}, j = 1,...,c</math>

при <math>D_{ij} =0</math> : <math>w_{ij} = \delta_{ij}, j = 1,...,c</math>, где <math>\delta_{ij}</math> - символ Кронекера

6) Если <math>|| F - F^{*} || < \varepsilon </math>, где <math>F^{*}</math> - матрица нечеткого разбиения предыдущей итерации, то идем далее, иначе возвращаемся на пункт 3.

7) Конец.

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

Вычислительным ядром алгоритма являются пункты (3), (4), (5) - расчет центроидов, вычисление расстояний и пересчет элементов матрицы соответственно

== Макроструктура алгоритма ==
Основные шаги при реализации алгоритма
* Генерация случайной матрицы размера <math>M</math> на где <math>c</math>, проверка условий
* Расчет центроидов – по сути, скалярное произведение с нормировкой
* Расчет расстояний – в общепринятом случае является скалярным произведением
* Пересчет матрицы – по сути, скалярное произведение
* Проверка условий останова – вычисление нормы

== Схема реализации последовательного алгоритма ==
float ** FuzzyCMeans (float** X, c, m, eps){
n = X.size();
r = X[0].size();
centers = generateZeroFill(c, r)
Wprev = genetateRandFill(n, c);
W = Wprev;
while (true){
// обновляем центры кластеров
for (int i=0; i<c; i++){
float * num = new float []();
float den = 0;
for (int j=0; j<n; j++){
num += pow(W[j][i], m) * X[j];
den+=pow(W[j][i], m);
}
centers[i] = num / den;
}
//обновляем вероятности W и считаем расстояние между матрицами W и Wprev
float max_diff = 0;
for (int i=0; i<n; i++)
for (int j=0; j<c; j++){
total = 0;
for (int m=0; m<с; m++)
total += pow(distance(X[i], centers[j]) / distance(X[i], centers[m]), 2/(m-1));
W[i][j] = 1/total;
max_diff = max(abs(Wprev[i][j]-W[i][j]), max_diff);
Wprev[i][j] = W[i][j];
}
if (max_diff < eps):
break;
}
return W;
}

== Последовательная сложность алгоритма ==
Последовательная сложность алгоритма состоит из сложности каждой итерации умноженной на их количество. Так как число итераций заранее неизвестно и зависит от входных параметров, рассмотрим сложность на каждой итерации. Наибольшую сложность представляет собой пересчет матрицы, сложность которого <math>O(c^2 nd)</math> (по сравнению со сложностью <math>O(cnd)</math> расчета расстояний, вычисления центроидов и проверки условия останова). Итого общая сложность алгоритма <math>O(c^2 ndi)</math>

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

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

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

* Входные данные алгоритма: набор векторов <math>x_i</math> размерности <math>d</math>, где <math>i = 1,...,M</math>; M - количество векторов.
* Выходные данные алгоритма: матрица размерности <math>M</math> на <math>c</math>.

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

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

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

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

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

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

2016-10-14T15:59:03Z

Yushin:

{{algorithm
| name = Нечеткий алгоритм C средних
| serial_complexity = <math>O(ndc^2i)</math>, <math>i</math> - количество итераций
| input_data = <math>n*d</math>, [количество наблюдений * размерность]
| output_data = <math>n*c</math>, [количество наблюдений * количество кластеров]
| pf_height = <math></math>
| pf_width = <math></math>
}}

Авторы : [[Участник:Gkhazeeva|Гелана Хазеева]], [[Участник:Yushin|Павел Юшин]]

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

== Общее описание алгоритма ==
Кластеризация - это объединение объектов в группы (кластеры) на основе схожести признаков для объектов одной группы и отличий между группами. Нечеткий алгоритм C Средних (Fuzzy C-means, FCM) - алгоритм кластеризации, позволяющий объектам принадлежать с различной степенью нескольким кластерам одновременно. Впервые алгоритм был предложен J.C. Dunn в 1973 <ref>{{Cite journal|last=Dunn|first=J. C.|date=1973-01-01|title=A Fuzzy Relative of the ISODATA Process and Its Use in Detecting Compact Well-Separated Clusters|url=http://dx.doi.org/10.1080/01969727308546046|journal=Journal of Cybernetics|volume=3|issue=3|pages=32–57|doi=10.1080/01969727308546046|issn=0022-0280}}</ref>. Нечеткое разбиение позволяет просто решить проблему объектов, расположенных на границе двух кластеров - им назначают степени принадлежностей равные 0.5.

Входные данные алгоритма: набор векторов, которые следует кластеризовать.

Параметры алгоритма: <math>c</math> - количество кластеров; <math>m</math> - экспоненциальный вес; <math>\varepsilon</math> - параметр останова алгоритма.

Выходные данные: матрица вероятностей принадлежности векторов кластерам.

Краткое описание алгоритма:

* Задать параметры алгоритма.

* Сгенерировать случайную матрицу принадлежностей векторов кластерам (матрицу нечеткого разбиения).

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

== Математическое описание алгоритма <ref>http://it-claim.ru/Persons/Neyskiy/Article2_Neiskiy.pdf</ref> ==

Пусть <math> W = w_{ij} \in[0,1],\; i = 1, ..., M, \; j = 1, ..., c</math> - матрица разбиения, где <math>w_{i,j}</math> - степень принадлежности объекта <math>i</math> к кластеру <math>j</math>; <math>c</math> - количество кластеров, <math>M</math> - количество векторов.

При этом элементы матрицы должны удовлетворять условиям:

* <math>\sum_{j = 1}^c w_{ij} = 1, i = 1, ..., M</math> <math>(1)</math>
* <math>0 < \sum_{i = 1}^M w_{ij} < M, j = 1, ..., c</math> <math>(2)</math>

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

1) Задаем параметры алгоритма: <math>c</math> - количество кластеров; <math>m >= 1</math> - экспоненциальный вес, определяющий нечеткость кластеров; <math>\varepsilon > 0</math> - параметр останова алгоритма.

2) Генерируем случайным образом матрицу нечеткого разбиения с учетом условий <math>(1)</math> и <math>(2)</math>

3) Рассчитываем центроиды (центры кластеров): <math>V_j = {{\sum_{i=1}^M w_{ij}^m * X_i} \over {\sum_{i=1}^M w_{ij}^m}}, j = 1, ..., c</math>

4) Рассчитываем расстояния между объектами <math>X</math> и центроидами:

<math>D_{ij} = {||X_i - V_j||}, i = 1,...,M; j = 1,...,c </math>

5) Пересчет элементов матрицы разбиения:

при <math>D_{ij} >0</math> : <math>w_{ij} = {{1}\over {{ (\sum_{k=1}^c {{D_{ij}}\over{D_{ik}}} ) }^{2/(m-1)}}}, j = 1,...,c</math>

при <math>D_{ij} =0</math> : <math>w_{ij} = \delta_{ij}, j = 1,...,c</math>, где <math>\delta_{ij}</math> - символ Кронекера

6) Если <math>|| F - F^{*} || < \varepsilon </math>, где <math>F^{*}</math> - матрица нечеткого разбиения предыдущей итерации, то идем далее, иначе возвращаемся на пункт 3.

7) Конец.

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

Вычислительным ядром алгоритма являются пункты (3), (4), (5) - расчет центроидов, вычисление расстояний и пересчет элементов матрицы соответственно

== Макроструктура алгоритма ==
Основные шаги при реализации алгоритма
* Генерация случайной матрицы размера <math>M</math> на где <math>c</math>, проверка условий
* Расчет центроидов – по сути, скалярное произведение с нормировкой
* Расчет расстояний – в общепринятом случае является скалярным произведением
* Пересчет матрицы – по сути, скалярное произведение
* Проверка условий останова – вычисление нормы

== Схема реализации последовательного алгоритма ==
float ** FuzzyCMeans (float** X, c, m, eps){
n = X.size();
r = X[0].size();
centers = generateZeroFill(c, r)
Wprev = genetateRandFill(n, c);
W = Wprev;
while (true){
// обновляем центры кластеров
for (int i=0; i<c; i++){
float * num = new float []();
float den = 0;
for (int j=0; j<n; j++){
num += pow(W[j][i], m) * X[j];
den+=pow(W[j][i], m);
}
centers[i] = num / den;
}
//обновляем вероятности W и считаем расстояние между матрицами W и Wprev
float max_diff = 0;
for (int i=0; i<n; i++)
for (int j=0; j<c; j++){
total = 0;
for (int m=0; m<с; m++)
total += pow(distance(X[i], centers[j]) / distance(X[i], centers[m]), 2/(m-1));
W[i][j] = 1/total;
max_diff = max(abs(Wprev[i][j]-W[i][j]), max_diff);
Wprev[i][j] = W[i][j];
}
if (max_diff < eps):
break;
}
return W;
}

== Последовательная сложность алгоритма ==
Последовательная сложность алгоритма состоит из сложности каждой итерации умноженной на их количество. Так как число итераций заранее неизвестно и зависит от входных параметров, рассмотрим сложность на каждой итерации. Наибольшую сложность представляет собой пересчет матрицы, сложность которого <math>O(c^2 nd)</math> (по сравнению со сложностью <math>O(cnd)</math> расчета расстояний, вычисления центроидов и проверки условия останова). Итого общая сложность алгоритма <math>O(c^2 ndi)</math>

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

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

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

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

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

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

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

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

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

2016-10-14T15:54:50Z

Yushin:

{{algorithm
| name = Нечеткий алгоритм C средних
| serial_complexity = <math>O(ndc^2i)</math>, <math>i</math> - количество итераций
| input_data = <math>n*d</math>, [количество наблюдений * размерность]
| output_data = <math>n*c</math>, [количество наблюдений * количество кластеров]
| pf_height = <math></math>
| pf_width = <math></math>
}}

Авторы : [[Участник:Gkhazeeva|Гелана Хазеева]], [[Участник:Yushin|Павел Юшин]]

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

== Общее описание алгоритма ==
Кластеризация - это объединение объектов в группы (кластеры) на основе схожести признаков для объектов одной группы и отличий между группами. Нечеткий алгоритм C Средних (Fuzzy C-means, FCM) - алгоритм кластеризации, позволяющий объектам принадлежать с различной степенью нескольким кластерам одновременно. Впервые алгоритм был предложен J.C. Dunn в 1973 <ref>{{Cite journal|last=Dunn|first=J. C.|date=1973-01-01|title=A Fuzzy Relative of the ISODATA Process and Its Use in Detecting Compact Well-Separated Clusters|url=http://dx.doi.org/10.1080/01969727308546046|journal=Journal of Cybernetics|volume=3|issue=3|pages=32–57|doi=10.1080/01969727308546046|issn=0022-0280}}</ref>. Нечеткое разбиение позволяет просто решить проблему объектов, расположенных на границе двух кластеров - им назначают степени принадлежностей равные 0.5.

Входные данные алгоритма: набор векторов, которые следует кластеризовать.

Параметры алгоритма: <math>c</math> - количество кластеров; <math>m</math> - экспоненциальный вес; <math>\varepsilon</math> - параметр останова алгоритма.

Выходные данные: матрица вероятностей принадлежности векторов кластерам.

Краткое описание алгоритма:

* Задать параметры алгоритма.

* Сгенерировать случайную матрицу принадлежностей векторов кластерам (матрицу нечеткого разбиения).

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

== Математическое описание алгоритма <ref>http://it-claim.ru/Persons/Neyskiy/Article2_Neiskiy.pdf</ref> ==

Пусть <math> W = w_{ij} \in[0,1],\; i = 1, ..., M, \; j = 1, ..., c</math> - матрица разбиения, где <math>w_{i,j}</math> - степень принадлежности объекта <math>i</math> к кластеру <math>j</math>; <math>c</math> - количество кластеров, <math>M</math> - количество векторов.

При этом элементы матрицы должны удовлетворять условиям:

* <math>\sum_{j = 1}^c w_{ij} = 1, i = 1, ..., M</math> <math>(1)</math>
* <math>0 < \sum_{i = 1}^M w_{ij} < M, j = 1, ..., c</math> <math>(2)</math>

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

1) Задаем параметры алгоритма: <math>c</math> - количество кластеров; <math>m >= 1</math> - экспоненциальный вес, определяющий нечеткость кластеров; <math>\varepsilon > 0</math> - параметр останова алгоритма.

2) Генерируем случайным образом матрицу нечеткого разбиения с учетом условий <math>(1)</math> и <math>(2)</math>

3) Рассчитываем центроиды (центры кластеров): <math>V_j = {{\sum_{i=1}^M w_{ij}^m * X_i} \over {\sum_{i=1}^M w_{ij}^m}}, j = 1, ..., c</math>

4) Рассчитываем расстояния между объектами <math>X</math> и центроидами:

<math>D_{ij} = {||X_i - V_j||}, i = 1,...,M; j = 1,...,c </math>

5) Пересчет элементов матрицы разбиения:

при <math>D_{ij} >0</math> : <math>w_{ij} = {{1}\over {{ (\sum_{k=1}^c {{D_{ij}}\over{D_{ik}}} ) }^{2/(m-1)}}}, j = 1,...,c</math>

при <math>D_{ij} =0</math> : <math>w_{ij} = \delta_{ij}, j = 1,...,c</math>, где <math>\delta_{ij}</math> - символ Кронекера

6) Если <math>|| F - F^{*} || < \varepsilon </math>, где <math>F^{*}</math> - матрица нечеткого разбиения предыдущей итерации, то идем далее, иначе возвращаемся на пункт 3.

7) Конец.

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

Вычислительным ядром алгоритма являются пункты (3), (4), (5) - расчет центроидов, вычисление расстояний и пересчет элементов матрицы соответственно

== Макроструктура алгоритма ==
Основные шаги при реализации алгоритма
* Генерация случайной матрицы размера <math>M</math> на где <math>c</math>, проверка условий
* Расчет центроидов – по сути, скалярное произведение с нормировкой
* Расчет расстояний – в общепринятом случае является скалярным произведением
* Пересчет матрицы – по сути, скалярное произведение
* Проверка условий останова – вычисление нормы

== Схема реализации последовательного алгоритма ==
float ** FuzzyCMeans (float** X, c, m, eps){
n = X.size();
r = X[0].size();
centers = generateZeroFill(c, r)
Wprev = genetateRandFill(n, c);
W = Wprev;
while (true){
// обновляем центры кластеров
for (int i=0; i<c; i++){
float * num = new float []();
float den = 0;
for (int j=0; j<n; j++){
num += pow(W[j][i], m) * X[j];
den+=pow(W[j][i], m);
}
centers[i] = num / den;
}
//обновляем вероятности W и считаем расстояние между матрицами W и Wprev
float max_diff = 0;
for (int i=0; i<n; i++)
for (int j=0; j<c; j++){
total = 0;
for (int m=0; m<с; m++)
total += pow(distance(X[i], centers[j]) / distance(X[i], centers[m]), 2/(m-1));
W[i][j] = 1/total;
max_diff = max(abs(Wprev[i][j]-W[i][j]), max_diff);
Wprev[i][j] = W[i][j];
}
if (max_diff < eps):
break;
}
return W;
}

== Последовательная сложность алгоритма ==
Последовательная сложность алгоритма состоит из сложности каждой итерации умноженной на их количество. Так как число итераций заранее неизвестно и зависит от входных параметров, рассмотрим сложность на каждой итерации. Наибольшую сложность представляет собой пересчет матрицы, сложность которого <math>O(c^2 nd)</math> (по сравнению со сложностью <math>O(cnd)</math> расчета расстояний, вычисления центроидов и проверки условия останова). Итого общая сложность алгоритма <math>O(c^2 ndi)</math>

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

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

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

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

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

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

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

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

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

2016-10-11T17:42:14Z

Yushin:

{{algorithm
| name = Нечеткий алгоритм C средних
| serial_complexity = <math>O(ndc^2i)</math>, <math>i</math> - количество итераций
| input_data = <math>n*d</math>, [количество наблюдений * размерность]
| output_data = <math>n*c</math>, [количество наблюдений * количество кластеров]
| pf_height = <math></math>
| pf_width = <math></math>
}}

Авторы : [[Участник:Gkhazeeva|Гелана Хазеева]], [[Участник:Yushin|Павел Юшин]]

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

== Общее описание алгоритма ==
Кластеризация - это объединение объектов в группы (кластеры) на основе схожести признаков для объектов одной группы и отличий между группами. Нечеткий алгоритм C Средних (Fuzzy C-means, FCM) - алгоритм кластеризации, позволяющий объектам принадлежать с различной степенью нескольким кластерам одновременно. Впервые алгоритм был предложен J.C. Dunn в 1973 <ref>{{Cite journal|last=Dunn|first=J. C.|date=1973-01-01|title=A Fuzzy Relative of the ISODATA Process and Its Use in Detecting Compact Well-Separated Clusters|url=http://dx.doi.org/10.1080/01969727308546046|journal=Journal of Cybernetics|volume=3|issue=3|pages=32–57|doi=10.1080/01969727308546046|issn=0022-0280}}</ref>. Нечеткое разбиение позволяет просто решить проблему объектов, расположенных на границе двух кластеров - им назначают степени принадлежностей равные 0.5.

Входные данные алгоритма: набор векторов, которые следует кластеризовать.

Параметры алгоритма: <math>c</math> - количество кластеров; <math>m</math> - экспоненциальный вес; <math>\varepsilon</math> - параметр останова алгоритма.

Выходные данные: матрица вероятностей принадлежности векторов кластерам.

Краткое описание алгоритма:

* Задать параметры алгоритма.

* Сгенерировать случайную матрицу принадлежностей векторов кластерам (матрицу нечеткого разбиения).

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

== Математическое описание алгоритма <ref>http://it-claim.ru/Persons/Neyskiy/Article2_Neiskiy.pdf</ref> ==

Пусть <math> W = w_{ij} \in[0,1],\; i = 1, ..., M, \; j = 1, ..., c</math> - матрица разбиения, где <math>w_{i,j}</math> - степень принадлежности объекта <math>i</math> к кластеру <math>j</math>; <math>c</math> - количество кластеров, <math>M</math> - количество векторов.

При этом элементы матрицы должны удовлетворять условиям:

* <math>\sum_{j = 1}^c w_{ij} = 1, i = 1, ..., M</math> <math>(1)</math>
* <math>0 < \sum_{i = 1}^M w_{ij} < M, j = 1, ..., c</math> <math>(2)</math>

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

1) Задаем параметры алгоритма: <math>c</math> - количество кластеров; <math>m >= 1</math> - экспоненциальный вес, определяющий нечеткость кластеров; <math>\varepsilon > 0</math> - параметр останова алгоритма.

2) Генерируем случайным образом матрицу нечеткого разбиения с учетом условий <math>(1)</math> и <math>(2)</math>

3) Рассчитываем центроиды (центры кластеров): <math>V_j = {{\sum_{i=1}^M w_{ij}^m * |X_i|} \over {\sum_{i=1}^M w_{ij}^m}}, j = 1, ..., c</math>

4) Рассчитываем расстояния между объектами <math>X</math> и центроидами:

<math>D_{ij} = \sqrt{{||X_i - V_j||}^2}, i = 1,...,M; j = 1,...,c </math>

5) Пересчет элементов матрицы разбиения:

при <math>D_{ki} >0</math> : <math>w_{kj} = {{1}\over {{ ( D_{jk}^2 * \sum_{j=1}^c {{1}\over{D_{jk}^2}} ) }^{1/(m-1)}}}, j = 1,...,c</math>

при <math>D_{ki} =0</math> : <math>w_{kj} = \delta_{ji}, j = 1,...,c</math>, где <math>\delta_{ji}</math> - символ Кронекера

6) Если <math>|| F - F^{*} || < \varepsilon </math>, где <math>F^{*}</math> - матрица нечеткого разбиения предыдущей итерации, то идем далее, иначе возвращаемся на пункт 3.

7) Конец.

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

Вычислительным ядром алгоритма являются пункты (3), (4), (5) - расчет центроидов, вычисление расстояний и пересчет элементов матрицы соответственно

== Макроструктура алгоритма ==
Основные шаги при реализации алгоритма
* Генерация случайной матрицы размера <math>M</math> на где <math>c</math>, проверка условий
* Расчет центроидов – по сути, скалярное произведение с нормировкой
* Расчет расстояний – в общепринятом случае является скалярным произведением
* Пересчет матрицы – по сути, скалярное произведение
* Проверка условий останова – вычисление нормы

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

== Последовательная сложность алгоритма ==
Последовательная сложность алгоритма состоит из сложности каждой итерации умноженной на их количество. Так как число итераций заранее неизвестно и зависит от входных параметров, рассмотрим сложность на каждой итерации. Наибольшую сложность представляет собой расчет центроидов, сложность которого <math>O(c^2 nd)</math> (по сравнению со сложностью <math>O(cnd)</math> расчета расстояний, пересчета матрицы и проверки условия останова). Итого общая сложность алгоритма <math>O(c^2 ndi)</math>

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

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

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

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

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

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

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

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

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

2016-10-10T22:43:33Z

Yushin:

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

2016-10-10T22:43:14Z

Yushin:

{{algorithm
| name = Нечеткий алгоритм C средних
| serial_complexity = <math>O(ndc^2i)</math>, <math>i<\math> - количество итераций
| input_data = <math>n*d</math>, [количество наблюдений x размерность]
| output_data = <math>n*c</math>, [количество наблюдений x количество кластеров]
| pf_height = <math></math>
| pf_width = <math></math>
}}

Авторы : [[Участник:Gkhazeeva|Гелана Хазеева]], [[Участник:Yushin|Павел Юшин]]

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

== Общее описание алгоритма ==
Кластеризация - это объединение объектов в группы (кластеры) на основе схожести признаков для объектов одной группы и отличий между группами. Нечеткий алгоритм C Средних (Fuzzy C-means, FCM) - алгоритм кластеризации, позволяющий объектам принадлежать с различной степенью нескольким кластерам одновременно. Впервые алгоритм был предложен J.C. Dunn в 1973 <ref>{{Cite journal|last=Dunn|first=J. C.|date=1973-01-01|title=A Fuzzy Relative of the ISODATA Process and Its Use in Detecting Compact Well-Separated Clusters|url=http://dx.doi.org/10.1080/01969727308546046|journal=Journal of Cybernetics|volume=3|issue=3|pages=32–57|doi=10.1080/01969727308546046|issn=0022-0280}}</ref>. Нечеткое разбиение позволяет просто решить проблему объектов, расположенных на границе двух кластеров - им назначают степени принадлежностей равные 0.5.

Входные данные алгоритма: набор векторов, которые следует кластеризовать.

Параметры алгоритма: <math>c</math> - количество кластеров; <math>m</math> - экспоненциальный вес; <math>\varepsilon</math> - параметр останова алгоритма.

Выходные данные: матрица вероятностей принадлежности векторов кластерам.

Краткое описание алгоритма:

* Задать параметры алгоритма.

* Сгенерировать случайную матрицу принадлежностей векторов кластерам (матрицу нечеткого разбиения).

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

== Математическое описание алгоритма <ref>http://it-claim.ru/Persons/Neyskiy/Article2_Neiskiy.pdf</ref> ==

Пусть <math> W = w_{ij} \in[0,1],\; i = 1, ..., M, \; j = 1, ..., c</math> - матрица разбиения, где <math>w_{i,j}</math> - степень принадлежности объекта <math>i</math> к кластеру <math>j</math>; <math>c</math> - количество кластеров, <math>M</math> - количество векторов.

При этом элементы матрицы должны удовлетворять условиям:

* <math>\sum_{j = 1}^c w_{ij} = 1, i = 1, ..., M</math> <math>(1)</math>
* <math>0 < \sum_{i = 1}^M w_{ij} < M, j = 1, ..., c</math> <math>(2)</math>

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

1) Задаем параметры алгоритма: <math>c</math> - количество кластеров; <math>m >= 1</math> - экспоненциальный вес, определяющий нечеткость кластеров; <math>\varepsilon > 0</math> - параметр останова алгоритма.

2) Генерируем случайным образом матрицу нечеткого разбиения с учетом условий <math>(1)</math> и <math>(2)</math>

3) Рассчитываем центроиды (центры кластеров): <math>V_i = {{\sum_{i=1}^M w_{ij}^m * |X_i|} \over {\sum_{i=1}^M w_{ij}^m}}, j = 1, ..., c</math>

4) Рассчитываем расстояния между объектами <math>X</math> и центроидами:

<math>D_{ij} = \sqrt{{||X_i - V_j||}^2}, i = 1,...,M; j = 1,...,c </math>

5) Пересчет элементов матрицы разбиения:

при <math>D_{ki} >0</math> : <math>w_{kj} = {{1}\over {{ ( D_{jk}^2 * \sum_{j=1}^c {{1}\over{D_{jk}^2}} ) }^{1/(m-1)}}}, j = 1,...,c</math>

при <math>D_{ki} =0</math> : <math>w_{kj} = \delta_{ji}</math>, где <math>\delta_{ji}</math> - символ Кронекера

6) Если <math>|| F - F^{*} || < \varepsilon </math>, где <math>F^{*}</math> - матрица нечеткого разбиения предыдущей итерации, то идем далее, иначе возвращаемся на пункт 3.

7) Конец.

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

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

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

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

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

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

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

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

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

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

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

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

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

2016-10-10T22:12:53Z

Yushin:

{{algorithm
| name = Нечеткий алгоритм C средних
| serial_complexity = <math>O(ncl)</math>
| input_data = <math>n*d</math>, [количество наблюдений x размерность]
| output_data = <math>n*c</math>, [количество наблюдений x количество кластеров]
| pf_height = <math></math>
| pf_width = <math></math>
}}

Авторы : [[Участник:Gkhazeeva|Гелана Хазеева]], [[Участник:Yushin|Павел Юшин]]

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

== Общее описание алгоритма ==
Кластеризация - это объединение объектов в группы (кластеры) на основе схожести признаков для объектов одной группы и отличий между группами. Нечеткий алгоритм C Средних (Fuzzy C-means, FCM) - алгоритм кластеризации, позволяющий объектам принадлежать с различной степенью нескольким кластерам одновременно. Впервые алгоритм был предложен J.C. Dunn в 1973 <ref>{{Cite journal|last=Dunn|first=J. C.|date=1973-01-01|title=A Fuzzy Relative of the ISODATA Process and Its Use in Detecting Compact Well-Separated Clusters|url=http://dx.doi.org/10.1080/01969727308546046|journal=Journal of Cybernetics|volume=3|issue=3|pages=32–57|doi=10.1080/01969727308546046|issn=0022-0280}}</ref>. Нечеткое разбиение позволяет просто решить проблему объектов, расположенных на границе двух кластеров - им назначают степени принадлежностей равные 0.5.

Входные данные алгоритма: набор векторов, которые следует кластеризовать.

Параметры алгоритма: <math>c</math> - количество кластеров; <math>m</math> - экспоненциальный вес; <math>\varepsilon</math> - параметр останова алгоритма.

Выходные данные: матрица вероятностей принадлежности векторов кластерам.

Краткое описание алгоритма:

* Задать параметры алгоритма.

* Сгенерировать случайную матрицу принадлежностей векторов кластерам (матрицу нечеткого разбиения).

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

== Математическое описание алгоритма <ref>http://it-claim.ru/Persons/Neyskiy/Article2_Neiskiy.pdf</ref> ==

Пусть <math> W = w_{ij} \in[0,1],\; i = 1, ..., M, \; j = 1, ..., c</math> - матрица разбиения, где <math>w_{i,j}</math> - степень принадлежности объекта <math>i</math> к кластеру <math>j</math>; <math>c</math> - количество кластеров, <math>M</math> - количество векторов.

При этом элементы матрицы должны удовлетворять условиям:

* <math>\sum_{j = 1}^c w_{ij} = 1, i = 1, ..., M</math> <math>(1)</math>
* <math>0 < \sum_{i = 1}^M w_{ij} < M, j = 1, ..., c</math> <math>(2)</math>

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

1) Задаем параметры алгоритма: <math>c</math> - количество кластеров; <math>m >= 1</math> - экспоненциальный вес, определяющий нечеткость кластеров; <math>\varepsilon > 0</math> - параметр останова алгоритма.

2) Генерируем случайным образом матрицу нечеткого разбиения с учетом условий <math>(1)</math> и <math>(2)</math>

3) Рассчитываем центроиды (центры кластеров): <math>V_i = {{\sum_{i=1}^M w_{ij}^m * |X_i|} \over {\sum_{i=1}^M w_{ij}^m}}, j = 1, ..., c</math>

4) Рассчитываем расстояния между объектами <math>X</math> и центроидами:

<math>D_{ij} = \sqrt{{||X_i - V_j||}^2}, i = 1,...,M; j = 1,...,c </math>

5) Пересчет элементов матрицы разбиения:

при <math>D_{ki} >0</math> : <math>w_{kj} = {{1}\over {{ ( D_{jk}^2 * \sum_{j=1}^c {{1}\over{D_{jk}^2}} ) }^{1/(m-1)}}}, j = 1,...,c</math>

при <math>D_{ki} =0</math> : <math>w_{kj} = \delta_{ji}</math>, где <math>\delta_{ji}</math> - символ Кронекера

6) Если <math>|| F - F^{*} || < \varepsilon </math>, где <math>F^{*}</math> - матрица нечеткого разбиения предыдущей итерации, то идем далее, иначе возвращаемся на пункт 3.

7) Конец.

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

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

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

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

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

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

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

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

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

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

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

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

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

2016-10-10T22:12:21Z

Yushin:

{{algorithm
| name = Нечеткий алгоритм C средних
| serial_complexity = <math>O(ncl)</math>
| input_data = <math>n*d</math>, [количество наблюдений x размерность]
| output_data = <math>n*c</math>, [количество наблюдений x количество кластеров]
| pf_height = <math></math>
| pf_width = <math></math>
}}

Авторы : [[Участник:Gkhazeeva|Гелана Хазеева]], [[Участник:Yushin|Павел Юшин]]

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

== Общее описание алгоритма ==
Кластеризация - это объединение объектов в группы (кластеры) на основе схожести признаков для объектов одной группы и отличий между группами. Нечеткий алгоритм C Средних (Fuzzy C-means, FCM) - алгоритм кластеризации, позволяющий объектам принадлежать с различной степенью нескольким кластерам одновременно. Впервые алгоритм был предложен J.C. Dunn в 1973 <ref>{{Cite journal|last=Dunn|first=J. C.|date=1973-01-01|title=A Fuzzy Relative of the ISODATA Process and Its Use in Detecting Compact Well-Separated Clusters|url=http://dx.doi.org/10.1080/01969727308546046|journal=Journal of Cybernetics|volume=3|issue=3|pages=32–57|doi=10.1080/01969727308546046|issn=0022-0280}}</ref>. Нечеткое разбиение позволяет просто решить проблему объектов, расположенных на границе двух кластеров - им назначают степени принадлежностей равные 0.5.

Входные данные алгоритма: набор векторов, которые следует кластеризовать.

Параметры алгоритма: <math>c</math> - количество кластеров; <math>m</math> - экспоненциальный вес; <math>\varepsilon</math> - параметр останова алгоритма.

Выходные данные: матрица вероятностей принадлежности векторов кластерам.

Краткое описание алгоритма:

* Задать параметры алгоритма.

* Сгенерировать случайную матрицу принадлежностей векторов кластерам (матрицу нечеткого разбиения).

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

== Математическое описание алгоритма <ref>http://it-claim.ru/Persons/Neyskiy/Article2_Neiskiy.pdf</ref> ==

Пусть <math> W = w_{ij} \in[0,1],\; i = 1, ..., M, \; j = 1, ..., c</math> - матрица разбиения, где <math>w_{i,j}</math> - степень принадлежности объекта <math>i</math> к кластеру <math>j</math>; <math>c</math> - количество кластеров, <math>M</math> - количество векторов.

При этом элементы матрицы должны удовлетворять условиям:

* <math>\sum_{j = 1}^c w_{ij} = 1, i = 1, ..., M</math> <math>(1)</math>
* <math>0 < \sum_{i = 1}^M w_{ij} < M, j = 1, ..., c</math> <math>(2)</math>

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

1) Задаем параметры алгоритма: <math>c</math> - количество кластеров; <math>m >= 1</math> - экспоненциальный вес, определяющий нечеткость кластеров; <math>\varepsilon > 0</math> - параметр останова алгоритма.

2) Генерируем случайным образом матрицу нечеткого разбиения с учетом условий <math>(1)</math> и <math>(2)</math>

3) Рассчитываем центроиды (центры кластеров): <math>V_i = {{\sum_{i=1}^M w_{ij}^m * |X_i|} \over {\sum_{i=1}^M w{ij}^m}}, j = 1, ..., c</math>

4) Рассчитываем расстояния между объектами <math>X</math> и центроидами:

<math>D_{ij} = \sqrt{{||X_i - V_j||}^2}, i = 1,...,M; j = 1,...,c </math>

5) Пересчет элементов матрицы разбиения:

при <math>D_{ki} >0</math> : <math>w_{kj} = {{1}\over {{ ( D_{jk}^2 * \sum_{j=1}^c {{1}\over{D_{jk}^2}} ) }^{1/(m-1)}}}, j = 1,...,c</math>

при <math>D_{ki} =0</math> : <math>w_{kj} = \delta_{ji}</math>, где <math>\delta_{ji}</math> - символ Кронекера

6) Если <math>|| F - F^{*} || < \varepsilon </math>, где <math>F^{*}</math> - матрица нечеткого разбиения предыдущей итерации, то идем далее, иначе возвращаемся на пункт 3.

7) Конец.

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

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

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

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

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

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

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

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

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

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

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

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

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

2016-10-10T22:11:32Z

Yushin:

{{algorithm
| name = Нечеткий алгоритм C средних
| serial_complexity = <math>O(ncl)</math>
| pf_height = <math>n*d</math>, [количество наблюдений x размерность]
| pf_width = <math>n*c</math>, [количество наблюдений x количество кластеров]
| input_data = <math></math>
| output_data = <math></math>
}}

Авторы : [[Участник:Gkhazeeva|Гелана Хазеева]], [[Участник:Yushin|Павел Юшин]]

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

== Общее описание алгоритма ==
Кластеризация - это объединение объектов в группы (кластеры) на основе схожести признаков для объектов одной группы и отличий между группами. Нечеткий алгоритм C Средних (Fuzzy C-means, FCM) - алгоритм кластеризации, позволяющий объектам принадлежать с различной степенью нескольким кластерам одновременно. Впервые алгоритм был предложен J.C. Dunn в 1973 <ref>{{Cite journal|last=Dunn|first=J. C.|date=1973-01-01|title=A Fuzzy Relative of the ISODATA Process and Its Use in Detecting Compact Well-Separated Clusters|url=http://dx.doi.org/10.1080/01969727308546046|journal=Journal of Cybernetics|volume=3|issue=3|pages=32–57|doi=10.1080/01969727308546046|issn=0022-0280}}</ref>. Нечеткое разбиение позволяет просто решить проблему объектов, расположенных на границе двух кластеров - им назначают степени принадлежностей равные 0.5.

Входные данные алгоритма: набор векторов, которые следует кластеризовать.

Параметры алгоритма: <math>c</math> - количество кластеров; <math>m</math> - экспоненциальный вес; <math>\varepsilon</math> - параметр останова алгоритма.

Выходные данные: матрица вероятностей принадлежности векторов кластерам.

Краткое описание алгоритма:

* Задать параметры алгоритма.

* Сгенерировать случайную матрицу принадлежностей векторов кластерам (матрицу нечеткого разбиения).

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

== Математическое описание алгоритма <ref>http://it-claim.ru/Persons/Neyskiy/Article2_Neiskiy.pdf</ref> ==

Пусть <math> W = w_{ij} \in[0,1],\; i = 1, ..., M, \; j = 1, ..., c</math> - матрица разбиения, где <math>w_{i,j}</math> - степень принадлежности объекта <math>i</math> к кластеру <math>j</math>; <math>c</math> - количество кластеров, <math>M</math> - количество векторов.

При этом элементы матрицы должны удовлетворять условиям:

* <math>\sum_{j = 1}^c w_{ij} = 1, i = 1, ..., M</math> <math>(1)</math>
* <math>0 < \sum_{i = 1}^M w_{ij} < M, j = 1, ..., c</math> <math>(2)</math>

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

1) Задаем параметры алгоритма: <math>c</math> - количество кластеров; <math>m >= 1</math> - экспоненциальный вес, определяющий нечеткость кластеров; <math>\varepsilon > 0</math> - параметр останова алгоритма.

2) Генерируем случайным образом матрицу нечеткого разбиения с учетом условий <math>(1)</math> и <math>(2)</math>

3) Рассчитываем центроиды (центры кластеров): <math>V_i = {{\sum_{i=1}^M w_{ij}^m * |X_i|} \over {\sum_{i=1}^M w{ij}^m}}, j = 1, ..., c</math>

4) Рассчитываем расстояния между объектами <math>X</math> и центроидами:

<math>D_{ij} = \sqrt{{||X_i - V_j||}^2}, i = 1,...,M; j = 1,...,c </math>

5) Пересчет элементов матрицы разбиения:

при <math>D_{ki} >0</math> : <math>w_{kj} = {{1}\over {{ ( D_{jk}^2 * \sum_{j=1}^c {{1}\over{D_{jk}^2}} ) }^{1/(m-1)}}}, j = 1,...,c</math>

при <math>D_{ki} =0</math> : <math>w_{kj} = \delta_{ji}</math>, где <math>\delta_{ji}</math> - символ Кронекера

6) Если <math>|| F - F^{*} || < \varepsilon </math>, где <math>F^{*}</math> - матрица нечеткого разбиения предыдущей итерации, то идем далее, иначе возвращаемся на пункт 3.

7) Конец.

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

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

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

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

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

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

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

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

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

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

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

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

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

2016-10-10T21:58:00Z

Yushin:

{{algorithm
| name = Нечеткий алгоритм C средних
| serial_complexity = <math>O(ncl)</math>
| pf_height = <math></math>
| pf_width = <math></math>
| input_data = <math></math>
| output_data = <math></math>
}}

Авторы : [[Участник:Gkhazeeva|Гелана Хазеева]], [[Участник:Yushin|Павел Юшин]]

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

== Общее описание алгоритма ==
Кластеризация - это объединение объектов в группы (кластеры) на основе схожести признаков для объектов одной группы и отличий между группами. Нечеткий алгоритм C Средних (Fuzzy C-means, FCM) - алгоритм кластеризации, позволяющий объектам принадлежать с различной степенью нескольким кластерам одновременно. Впервые алгоритм был предложен J.C. Dunn в 1973 <ref>{{Cite journal|last=Dunn|first=J. C.|date=1973-01-01|title=A Fuzzy Relative of the ISODATA Process and Its Use in Detecting Compact Well-Separated Clusters|url=http://dx.doi.org/10.1080/01969727308546046|journal=Journal of Cybernetics|volume=3|issue=3|pages=32–57|doi=10.1080/01969727308546046|issn=0022-0280}}</ref>. Нечеткое разбиение позволяет просто решить проблему объектов, расположенных на границе двух кластеров - им назначают степени принадлежностей равные 0.5.

Входные данные алгоритма: набор векторов, которые следует кластеризовать.

Параметры алгоритма: <math>c</math> - количество кластеров; <math>m</math> - экспоненциальный вес; <math>\varepsilon</math> - параметр останова алгоритма.

Выходные данные: матрица вероятностей принадлежности векторов кластерам.

Краткое описание алгоритма:

* Задать параметры алгоритма.

* Сгенерировать случайную матрицу принадлежностей векторов кластерам (матрицу нечеткого разбиения).

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

== Математическое описание алгоритма <ref>http://it-claim.ru/Persons/Neyskiy/Article2_Neiskiy.pdf</ref> ==

Пусть <math> W = w_{ij} \in[0,1],\; i = 1, ..., M, \; j = 1, ..., c</math> - матрица разбиения, где <math>w_{i,j}</math> - степень принадлежности объекта <math>i</math> к кластеру <math>j</math>; <math>c</math> - количество кластеров, <math>M</math> - количество векторов.

При этом элементы матрицы должны удовлетворять условиям:

* <math>\sum_{j = 1}^c w_{ij} = 1, i = 1, ..., M</math> <math>(1)</math>
* <math>0 < \sum_{i = 1}^M w_{ij} < M, j = 1, ..., c</math> <math>(2)</math>

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

1) Задаем параметры алгоритма: <math>c</math> - количество кластеров; <math>m >= 1</math> - экспоненциальный вес, определяющий нечеткость кластеров; <math>\varepsilon > 0</math> - параметр останова алгоритма.

2) Генерируем случайным образом матрицу нечеткого разбиения с учетом условий <math>(1)</math> и <math>(2)</math>

3) Рассчитываем центроиды (центры кластеров): <math>V_i = {{\sum_{i=1}^M w_{ij}^m * |X_i|} \over {\sum_{i=1}^M w{ij}^m}}, j = 1, ..., c</math>

4) Рассчитываем расстояния между объектами <math>X</math> и центроидами:

<math>D_{ij} = \sqrt{{||X_i - V_j||}^2}, i = 1,...,M; j = 1,...,c </math>

5) Пересчет элементов матрицы разбиения:

при <math>D_{ki} >0</math> : <math>w_{kj} = {{1}\over {{ ( D_{jk}^2 * \sum_{j=1}^c {{1}\over{D_{jk}^2}} ) }^{1/(m-1)}}}, j = 1,...,c</math>

при <math>D_{ki} =0</math> : <math>w_{kj} = \delta_{ji}</math>, где <math>\delta_{ji}</math> - символ Кронекера

6) Если <math>|| F - F^{*} || < \varepsilon </math>, где <math>F^{*}</math> - матрица нечеткого разбиения предыдущей итерации, то идем далее, иначе возвращаемся на пункт 3.

7) Конец.

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

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

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

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

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

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

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

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

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

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

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

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

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

2016-10-10T21:44:16Z

Yushin:

{{algorithm
| name = Нечеткий алгоритм C средних
| serial_complexity = <math></math>
| pf_height = <math></math>
| pf_width = <math></math>
| input_data = <math></math>
| output_data = <math></math>
}}

Авторы : [[Участник:Gkhazeeva|Гелана Хазеева]], [[Участник:Yushin|Павел Юшин]]

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

== Общее описание алгоритма ==
Кластеризация - это объединение объектов в группы (кластеры) на основе схожести признаков для объектов одной группы и отличий между группами. Нечеткий алгоритм C Средних (Fuzzy C-means, FCM) - алгоритм кластеризации, позволяющий объектам принадлежать с различной степенью нескольким кластерам одновременно. Впервые алгоритм был предложен J.C. Dunn в 1973 <ref>{{Cite journal|last=Dunn|first=J. C.|date=1973-01-01|title=A Fuzzy Relative of the ISODATA Process and Its Use in Detecting Compact Well-Separated Clusters|url=http://dx.doi.org/10.1080/01969727308546046|journal=Journal of Cybernetics|volume=3|issue=3|pages=32–57|doi=10.1080/01969727308546046|issn=0022-0280}}</ref>. Нечеткое разбиение позволяет просто решить проблему объектов, расположенных на границе двух кластеров - им назначают степени принадлежностей равные 0.5.

Входные данные алгоритма: набор векторов, которые следует кластеризовать.

Параметры алгоритма: <math>c</math> - количество кластеров; <math>m</math> - экспоненциальный вес; <math>\varepsilon</math> - параметр останова алгоритма.

Выходные данные: матрица вероятностей принадлежности векторов кластерам.

Краткое описание алгоритма:

* Задать параметры алгоритма.

* Сгенерировать случайную матрицу принадлежностей векторов кластерам (матрицу нечеткого разбиения).

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

== Математическое описание алгоритма <ref>http://it-claim.ru/Persons/Neyskiy/Article2_Neiskiy.pdf</ref> ==

Пусть <math> W = w_{ij} \in[0,1],\; i = 1, ..., M, \; j = 1, ..., c</math> - матрица разбиения, где <math>w_{i,j}</math> - степень принадлежности объекта <math>i</math> к кластеру <math>j</math>; <math>c</math> - количество кластеров, <math>M</math> - количество векторов.

При этом элементы матрицы должны удовлетворять условиям:

* <math>\sum_{j = 1}^c w_{ij} = 1, i = 1, ..., M</math> <math>(1)</math>
* <math>0 < \sum_{i = 1}^M w_{ij} < M, j = 1, ..., c</math> <math>(2)</math>

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

1) Задаем параметры алгоритма: <math>c</math> - количество кластеров; <math>m >= 1</math> - экспоненциальный вес, определяющий нечеткость кластеров; <math>\varepsilon > 0</math> - параметр останова алгоритма.

2) Генерируем случайным образом матрицу нечеткого разбиения с учетом условий <math>(1)</math> и <math>(2)</math>

3) Рассчитываем центроиды (центры кластеров): <math>V_i = {{\sum_{i=1}^M w_{ij}^m * |X_i|} \over {\sum_{i=1}^M w{ij}^m}}, j = 1, ..., c</math>

4) Рассчитываем расстояния между объектами <math>X</math> и центроидами:

<math>D_{ij} = \sqrt{{||X_i - V_j||}^2}, i = 1,...,M; j = 1,...,c </math>

5) Пересчет элементов матрицы разбиения:

при <math>D_{ki} >0</math> : <math>w_{kj} = {{1}\over {{ ( D_{jk}^2 * \sum_{j=1}^c {{1}\over{D_{jk}^2}} ) }^{1/(m-1)}}}, j = 1,...,c</math>

при <math>D_{ki} =0</math> : <math>w_{kj} = \delta_{ji}</math>, где <math>\delta_{ji}</math> - символ Кронекера

6) Если <math>|| F - F^{*} || < \varepsilon </math>, где <math>F^{*}</math> - матрица нечеткого разбиения предыдущей итерации, то идем далее, иначе возвращаемся на пункт 3.

7) Конец.

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

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

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

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

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

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

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

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

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

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

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

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

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

2016-10-10T21:25:45Z

Yushin:

{{algorithm
| name = Нечеткий алгоритм C средних
| serial_complexity = <math></math>
| pf_height = <math></math>
| pf_width = <math></math>
| input_data = <math></math>
| output_data = <math></math>
}}

Авторы : [[Участник:Gkhazeeva|Гелана Хазеева]], [[Участник:Yushin|Павел Юшин]]

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

== Общее описание алгоритма ==
Кластеризация - это объединение объектов в группы (кластеры) на основе схожести признаков для объектов одной группы и отличий между группами. Нечеткий алгоритм C Средних (Fuzzy C-means, FCM) - алгоритм кластеризации, позволяющий объектам принадлежать с различной степенью нескольким кластерам одновременно. Впервые алгоритм был предложен J.C. Dunn в 1973 <ref>{{Cite journal|last=Dunn|first=J. C.|date=1973-01-01|title=A Fuzzy Relative of the ISODATA Process and Its Use in Detecting Compact Well-Separated Clusters|url=http://dx.doi.org/10.1080/01969727308546046|journal=Journal of Cybernetics|volume=3|issue=3|pages=32–57|doi=10.1080/01969727308546046|issn=0022-0280}}</ref>. Нечеткое разбиение позволяет просто решить проблему объектов, расположенных на границе двух кластеров - им назначают степени принадлежностей равные 0.5.

Входные данные алгоритма: набор векторов, которые следует кластеризовать.

Параметры алгоритма: <math>c</math> - количество кластеров; <math>m</math> - экспоненциальный вес; <math>\varepsilon</math> - параметр останова алгоритма.

Выходные данные: матрица вероятностей принадлежности векторов кластерам.

Краткое описание алгоритма:

* Задать параметры алгоритма.

* Сгенерировать случайную матрицу принадлежностей векторов кластерам (матрицу нечеткого разбиения).

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

== Математическое описание алгоритма <ref>http://it-claim.ru/Persons/Neyskiy/Article2_Neiskiy.pdf</ref> ==

Пусть <math> W = w_{ij} \in[0,1],\; i = 1, ..., M, \; j = 1, ..., c</math> - матрица разбиения, где <math>w_{i,j}</math> - степень принадлежности объекта <math>i</math> к кластеру <math>j</math>; <math>c</math> - количество кластеров, <math>M</math> - количество векторов.

При этом элементы матрицы должны удовлетворять условиям:

* <math>\sum_{j = 1}^c w_{ij} = 1, i = 1, ..., M</math> <math>(1)</math>
* <math>0 < \sum_{i = 1}^M w_{ij} < M, j = 1, ..., c</math> <math>(2)</math>

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

1) Задаем параметры алгоритма: <math>c</math> - количество кластеров; <math>m >= 1</math> - экспоненциальный вес, определяющий нечеткость кластеров; <math>\varepsilon > 0</math> - параметр останова алгоритма.

2) Генерируем случайным образом матрицу нечеткого разбиения с учетом условий <math>(1)</math> и <math>(2)</math>

3) Рассчитываем центроиды (центры кластеров): <math>V_i = {{\sum_{i=1}^M w_{ij}^m * |X_i|} \over {\sum_{i=1}^M w{ij}^m}}, j = 1, ..., c</math>

4) Рассчитываем расстояния между объектами <math>X</math> и центроидами:

<math>D_{ij} = \sqrt{{||X_i - V_j||}^2}, i = 1,...,M; j = 1,...,c </math>

5) Пересчет элементов матрицы разбиения:

при <math>D_{ki} >0</math> : <math>w_{kj} = {{1}\over {{D_{jk}^2 * \sum_{j=1}^c {{1}\over{D_{jk}^2}}}^{1/(m-1)}}}, j = 1,...,c</math>

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

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

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

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

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

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

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

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

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

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

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

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

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

2016-10-10T21:15:27Z

Yushin:

{{algorithm
| name = Нечеткий алгоритм C средних
| serial_complexity = <math></math>
| pf_height = <math></math>
| pf_width = <math></math>
| input_data = <math></math>
| output_data = <math></math>
}}

Авторы : [[Участник:Gkhazeeva|Гелана Хазеева]], [[Участник:Yushin|Павел Юшин]]

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

== Общее описание алгоритма ==
Кластеризация - это объединение объектов в группы (кластеры) на основе схожести признаков для объектов одной группы и отличий между группами. Нечеткий алгоритм C Средних (Fuzzy C-means, FCM) - алгоритм кластеризации, позволяющий объектам принадлежать с различной степенью нескольким кластерам одновременно. Впервые алгоритм был предложен J.C. Dunn в 1973 <ref>{{Cite journal|last=Dunn|first=J. C.|date=1973-01-01|title=A Fuzzy Relative of the ISODATA Process and Its Use in Detecting Compact Well-Separated Clusters|url=http://dx.doi.org/10.1080/01969727308546046|journal=Journal of Cybernetics|volume=3|issue=3|pages=32–57|doi=10.1080/01969727308546046|issn=0022-0280}}</ref>. Нечеткое разбиение позволяет просто решить проблему объектов, расположенных на границе двух кластеров - им назначают степени принадлежностей равные 0.5.

Входные данные алгоритма: набор векторов, которые следует кластеризовать.

Параметры алгоритма: <math>c</math> - количество кластеров; <math>m</math> - экспоненциальный вес; <math>\varepsilon</math> - параметр останова алгоритма.

Выходные данные: матрица вероятностей принадлежности векторов кластерам.

Краткое описание алгоритма:

* Задать параметры алгоритма.

* Сгенерировать случайную матрицу принадлежностей векторов кластерам (матрицу нечеткого разбиения).

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

== Математическое описание алгоритма <ref>http://it-claim.ru/Persons/Neyskiy/Article2_Neiskiy.pdf</ref> ==

Пусть <math> W = w_{ij} \in[0,1],\; i = 1, ..., M, \; j = 1, ..., c</math> - матрица разбиения, где <math>w_{i,j}</math> - степень принадлежности объекта <math>i</math> к кластеру <math>j</math>; <math>c</math> - количество кластеров, <math>M</math> - количество векторов.

При этом элементы матрицы должны удовлетворять условиям:

* <math>\sum_{j = 1}^c w_{ij} = 1, i = 1, ..., M</math> <math>(1)</math>
* <math>0 < \sum_{i = 1}^M w_{ij} < M, j = 1, ..., c</math> <math>(2)</math>

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

1) Задаем параметры алгоритма: <math>c</math> - количество кластеров; <math>m >= 1</math> - экспоненциальный вес, определяющий нечеткость кластеров; <math>\varepsilon > 0</math> - параметр останова алгоритма.

2) Генерируем случайным образом матрицу нечеткого разбиения с учетом условий <math>(1)</math> и <math>(2)</math>

3) Рассчитываем центроиды (центры кластеров): <math>V_i = {{\sum_{i=1}^M w_{ij}^m * |X_i|} \over {\sum_{i=1}^M w{ij}^m}}, j = 1, ..., c</math>

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

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

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

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

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

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

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

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

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

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

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

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

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

2016-10-10T20:59:45Z

Yushin:

{{algorithm
| name = Нечеткий алгоритм C средних
| serial_complexity = <math></math>
| pf_height = <math></math>
| pf_width = <math></math>
| input_data = <math></math>
| output_data = <math></math>
}}

Авторы : [[Участник:Gkhazeeva|Гелана Хазеева]], [[Участник:Yushin|Павел Юшин]]

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

== Общее описание алгоритма ==
Кластеризация - это объединение объектов в группы (кластеры) на основе схожести признаков для объектов одной группы и отличий между группами. Нечеткий алгоритм C Средних (Fuzzy C-means, FCM) - алгоритм кластеризации, позволяющий объектам принадлежать с различной степенью нескольким кластерам одновременно. Впервые алгоритм был предложен J.C. Dunn в 1973 <ref>{{Cite journal|last=Dunn|first=J. C.|date=1973-01-01|title=A Fuzzy Relative of the ISODATA Process and Its Use in Detecting Compact Well-Separated Clusters|url=http://dx.doi.org/10.1080/01969727308546046|journal=Journal of Cybernetics|volume=3|issue=3|pages=32–57|doi=10.1080/01969727308546046|issn=0022-0280}}</ref>. Нечеткое разбиение позволяет просто решить проблему объектов, расположенных на границе двух кластеров - им назначают степени принадлежностей равные 0.5.

Входные данные алгоритма: набор векторов, которые следует кластеризовать.

Параметры алгоритма: <math>c</math> - количество кластеров; <math>m</math> - экспоненциальный вес; <math>\varepsilon</math> - параметр останова алгоритма.

Выходные данные: матрица вероятностей принадлежности векторов кластерам.

Краткое описание алгоритма:

* Задать параметры алгоритма.

* Сгенерировать случайную матрицу принадлежностей векторов кластерам (матрицу нечеткого разбиения).

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

== Математическое описание алгоритма <ref>http://it-claim.ru/Persons/Neyskiy/Article2_Neiskiy.pdf</ref> ==

Пусть <math> W = w_{ij} \in[0,1],\; i = 1, ..., M, \; j = 1, ..., c</math> - матрица разбиения, где <math>w_{i,j}</math> - степень принадлежности объекта <math>i</math> к кластеру <math>j</math>; <math>c</math> - количество кластеров, <math>M</math> - количество векторов.

При этом элементы матрицы должны удовлетворять условиям

* <math>\sum_{j = 1}^c w_{ij} = 1, i = 1, ..., M</math> <math>(1)</math>
* <math>0 < \sum_{i = 1}^M w_{ij} < M, j = 1, ..., c</math> <math>(2)</math>

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

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

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

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

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

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

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

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

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

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

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

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

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

2016-10-10T20:57:49Z

Yushin:

{{algorithm
| name = Нечеткий алгоритм C средних
| serial_complexity = <math></math>
| pf_height = <math></math>
| pf_width = <math></math>
| input_data = <math></math>
| output_data = <math></math>
}}

Авторы : [[Участник:Gkhazeeva|Гелана Хазеева]], [[Участник:Yushin|Павел Юшин]]

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

== Общее описание алгоритма ==
Кластеризация - это объединение объектов в группы (кластеры) на основе схожести признаков для объектов одной группы и отличий между группами. Нечеткий алгоритм C Средних (Fuzzy C-means, FCM) - алгоритм кластеризации, позволяющий объектам принадлежать с различной степенью нескольким кластерам одновременно. Впервые алгоритм был предложен J.C. Dunn в 1973 <ref>{{Cite journal|last=Dunn|first=J. C.|date=1973-01-01|title=A Fuzzy Relative of the ISODATA Process and Its Use in Detecting Compact Well-Separated Clusters|url=http://dx.doi.org/10.1080/01969727308546046|journal=Journal of Cybernetics|volume=3|issue=3|pages=32–57|doi=10.1080/01969727308546046|issn=0022-0280}}</ref>. Нечеткое разбиение позволяет просто решить проблему объектов, расположенных на границе двух кластеров - им назначают степени принадлежностей равные 0.5.

Входные данные алгоритма: набор векторов, которые следует кластеризовать.

Параметры алгоритма: <math>c</math> - количество кластеров; <math>m</math> - экспоненциальный вес; <math>\varepsilon</math> - параметр останова алгоритма.

Выходные данные: матрица вероятностей принадлежности векторов кластерам.

Краткое описание алгоритма:

* Задать параметры алгоритма.

* Сгенерировать случайную матрицу принадлежностей векторов кластерам (матрицу нечеткого разбиения).

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

== Математическое описание алгоритма <ref>http://it-claim.ru/Persons/Neyskiy/Article2_Neiskiy.pdf</ref> ==

Пусть <math> W = w_{ij} \in[0,1],\; i = 1, ..., M, \; j = 1, ..., c</math> - матрица разбиения, где <math>w_{i,j}</math> - степень принадлежности объекта <math>i</math> к кластеру <math>j</math>; <math>c</math> - количество кластеров, <math>M</math> - количество векторов.

При этом элементы матрицы должны удовлетворять условиям

* <math>/sum_{j = 1}^c w_{ij} = 1, i = 1, ..., M (1)</math>

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

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

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

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

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

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

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

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

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

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

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

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