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

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

2016-12-19T20:58:59Z

Gkhazeeva:

{{Assignment|Coctic}}

{{algorithm
| name = Нечеткий алгоритм C средних
| serial_complexity = <math>O(c^2 Mn_{iter} + cMdn_{iter})</math>, <math>n_{iter} </math> - количество итераций
| input_data = <math>M*d</math>, [количество наблюдений * размерность]
| output_data = <math>M*c</math>, [количество наблюдений * количество кластеров]
| pf_height = <math>O(cdn_{iter} + c^2n_{iter})</math>
| pf_width = <math>O (M) </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>m = 1</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>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> n_{iter} </math>. Так как число итераций заранее неизвестно и зависит от входных параметров, рассмотрим сложность на каждой итерации. Наибольшую сложность представляет собой пересчет матрицы, сложность которого <math>O(c^2 M)</math> (по сравнению со сложностью <math>O(cMd)</math> расчета расстояний, вычисления центроидов и проверки условия останова). Итого общая сложность алгоритма <math>O(c^2 Mn_{iter} + cMdn_{iter})</math>. Так как обычно <math> n >> c </math>, то в этом случае сложность <math>O(c^2 Mn_{iter} )</math>.

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

'''Первый ярус''' состоит из <math>n_{p}</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>n_{p}</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> O(cdn_{iter}) </math> операций, на втором - <math> O(c^2n_{iter}) </math>, итого высота ЯПФ алгоритма <math> O(cdn_{iter} + c^2n_{iter}) </math>. Ширина ярусно-параллельной формы алгоритма равна <math> O(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^2n_{iter} } \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-19T20:57:42Z

Gkhazeeva:

{{Assignment|Coctic}}

{{algorithm
| name = Нечеткий алгоритм C средних
| serial_complexity = <math>O(Mc^2n_{iter} )</math>, <math>n_{iter} </math> - количество итераций
| input_data = <math>M*d</math>, [количество наблюдений * размерность]
| output_data = <math>M*c</math>, [количество наблюдений * количество кластеров]
| pf_height = <math>O(cdn_{iter} + c^2n_{iter})</math>
| pf_width = <math>O (M) </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>m = 1</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>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> n_{iter} </math>. Так как число итераций заранее неизвестно и зависит от входных параметров, рассмотрим сложность на каждой итерации. Наибольшую сложность представляет собой пересчет матрицы, сложность которого <math>O(c^2 M)</math> (по сравнению со сложностью <math>O(cMd)</math> расчета расстояний, вычисления центроидов и проверки условия останова). Итого общая сложность алгоритма <math>O(c^2 Mn_{iter} + cMdn_{iter})</math>. Так как обычно <math> n >> c </math>, то в этом случае сложность <math>O(c^2 Mn_{iter} )</math>.

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

'''Первый ярус''' состоит из <math>n_{p}</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>n_{p}</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> O(cdn_{iter}) </math> операций, на втором - <math> O(c^2n_{iter}) </math>, итого высота ЯПФ алгоритма <math> O(cdn_{iter} + c^2n_{iter}) </math>. Ширина ярусно-параллельной формы алгоритма равна <math> O(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^2n_{iter} } \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-19T20:56:30Z

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

{{Assignment|Coctic}}

{{algorithm
| name = Нечеткий алгоритм C средних
| serial_complexity = <math>O(Mc^2n_{iter} )</math>, <math>n_{iter} </math> - количество итераций
| input_data = <math>M*d</math>, [количество наблюдений * размерность]
| output_data = <math>M*c</math>, [количество наблюдений * количество кластеров]
| pf_height = <math>2n_{iter} </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>m = 1</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>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> n_{iter} </math>. Так как число итераций заранее неизвестно и зависит от входных параметров, рассмотрим сложность на каждой итерации. Наибольшую сложность представляет собой пересчет матрицы, сложность которого <math>O(c^2 M)</math> (по сравнению со сложностью <math>O(cMd)</math> расчета расстояний, вычисления центроидов и проверки условия останова). Итого общая сложность алгоритма <math>O(c^2 Mn_{iter} + cMdn_{iter})</math>. Так как обычно <math> n >> c </math>, то в этом случае сложность <math>O(c^2 Mn_{iter} )</math>.

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

'''Первый ярус''' состоит из <math>n_{p}</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>n_{p}</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> O(cdn_{iter}) </math> операций, на втором - <math> O(c^2n_{iter}) </math>, итого высота ЯПФ алгоритма <math> O(cdn_{iter} + c^2n_{iter}) </math>. Ширина ярусно-параллельной формы алгоритма равна <math> O(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^2n_{iter} } \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-19T20:15:34Z

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

{{Assignment|Coctic}}

{{algorithm
| name = Нечеткий алгоритм C средних
| serial_complexity = <math>O(Mc^2n_{iter} )</math>, <math>n_{iter} </math> - количество итераций
| input_data = <math>M*d</math>, [количество наблюдений * размерность]
| output_data = <math>M*c</math>, [количество наблюдений * количество кластеров]
| pf_height = <math>2n_{iter} </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>m = 1</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>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> n_{iter} </math>. Так как число итераций заранее неизвестно и зависит от входных параметров, рассмотрим сложность на каждой итерации. Наибольшую сложность представляет собой пересчет матрицы, сложность которого <math>O(c^2 M)</math> (по сравнению со сложностью <math>O(cMd)</math> расчета расстояний, вычисления центроидов и проверки условия останова). Итого общая сложность алгоритма <math>O(c^2 Mn_{iter} + cMdn_{iter})</math>. Так как обычно <math> n >> c </math>, то в этом случае сложность <math>O(c^2 Mn_{iter} )</math>.

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

'''Первый ярус''' состоит из <math>n_{p}</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>n_{p}</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*n_{iter} </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^2n_{iter} } \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-19T19:56:08Z

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

{{Assignment|Coctic}}

{{algorithm
| name = Нечеткий алгоритм C средних
| serial_complexity = <math>O(Mc^2n_{iter} )</math>, <math>n_{iter} </math> - количество итераций
| input_data = <math>M*d</math>, [количество наблюдений * размерность]
| output_data = <math>M*c</math>, [количество наблюдений * количество кластеров]
| pf_height = <math>2n_{iter} </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>m = 1</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>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> n_{iter} </math>. Так как число итераций заранее неизвестно и зависит от входных параметров, рассмотрим сложность на каждой итерации. Наибольшую сложность представляет собой пересчет матрицы, сложность которого <math>O(c^2 M)</math> (по сравнению со сложностью <math>O(cMd)</math> расчета расстояний, вычисления центроидов и проверки условия останова). Итого общая сложность алгоритма <math>O(c^2 Mn_{iter} + cMdn_{iter})</math>. Так как обычно <math> n >> c </math>, то в этом случае сложность <math>O(c^2 Mn_{iter} )</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*n_{iter} </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^2n_{iter} } \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-19T19:55:35Z

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

{{Assignment|Coctic}}

{{algorithm
| name = Нечеткий алгоритм C средних
| serial_complexity = <math>O(Mc^2n_{iter} )</math>, <math>n_{iter} </math> - количество итераций
| input_data = <math>M*d</math>, [количество наблюдений * размерность]
| output_data = <math>M*c</math>, [количество наблюдений * количество кластеров]
| pf_height = <math>2n_{iter} </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>m = 1</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>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> n_{iter} </math>. Так как число итераций заранее неизвестно и зависит от входных параметров, рассмотрим сложность на каждой итерации. Наибольшую сложность представляет собой пересчет матрицы, сложность которого <math>O(c^2 M)</math> (по сравнению со сложностью <math>O(cMd)</math> расчета расстояний, вычисления центроидов и проверки условия останова). Итого общая сложность алгоритма <math>O(c^2 Mn_{iter} + cMdn_{iter})</math>. Так как обычно <math> n >> c </math>, то в этом случае сложность <math>O(c^2 Mn_{iter} )</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*n_{iter} </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^2n_{iter} } \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-19T19:51:02Z

Gkhazeeva:

{{Assignment|Coctic}}

{{algorithm
| name = Нечеткий алгоритм C средних
| serial_complexity = <math>O(Mc^2n_{iter} )</math>, <math>n_{iter} </math> - количество итераций
| input_data = <math>M*d</math>, [количество наблюдений * размерность]
| output_data = <math>M*c</math>, [количество наблюдений * количество кластеров]
| pf_height = <math>2n_{iter} </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>m = 1</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>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> n_{iter} </math>. Так как число итераций заранее неизвестно и зависит от входных параметров, рассмотрим сложность на каждой итерации. Наибольшую сложность представляет собой пересчет матрицы, сложность которого <math>O(c^2 M)</math> (по сравнению со сложностью <math>O(cMd)</math> расчета расстояний, вычисления центроидов и проверки условия останова). Итого общая сложность алгоритма <math>O(c^2 Mn_{iter} + cMdn_{iter})</math>. Так как обычно <math> n >> c </math>, то в этом случае сложность <math>O(c^2 Mn_{iter} )</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*n_{iter} </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^2n_{iter} } \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-19T19:50:11Z

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

{{Assignment|Coctic}}

{{algorithm
| name = Нечеткий алгоритм C средних
| serial_complexity = <math>O(Mdc^2n_{iter} )</math>, <math>n_{iter} </math> - количество итераций
| input_data = <math>M*d</math>, [количество наблюдений * размерность]
| output_data = <math>M*c</math>, [количество наблюдений * количество кластеров]
| pf_height = <math>2n_{iter} </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>m = 1</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>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> n_{iter} </math>. Так как число итераций заранее неизвестно и зависит от входных параметров, рассмотрим сложность на каждой итерации. Наибольшую сложность представляет собой пересчет матрицы, сложность которого <math>O(c^2 M)</math> (по сравнению со сложностью <math>O(cMd)</math> расчета расстояний, вычисления центроидов и проверки условия останова). Итого общая сложность алгоритма <math>O(c^2 Mn_{iter} + cMdn_{iter})</math>. Так как обычно <math> n >> c </math>, то в этом случае сложность <math>O(c^2 Mn_{iter} )</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*n_{iter} </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^2n_{iter} } \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-19T14:56:36Z

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

{{Assignment|Coctic}}

{{algorithm
| name = Нечеткий алгоритм C средних
| serial_complexity = <math>O(Mdc^2n_{iter} )</math>, <math>n_{iter} </math> - количество итераций
| input_data = <math>M*d</math>, [количество наблюдений * размерность]
| output_data = <math>M*c</math>, [количество наблюдений * количество кластеров]
| pf_height = <math>2n_{iter} </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>m = 1</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>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> n_{iter} </math>. Так как число итераций заранее неизвестно и зависит от входных параметров, рассмотрим сложность на каждой итерации. Наибольшую сложность представляет собой пересчет матрицы, сложность которого <math>O(c^2 Md)</math> (по сравнению со сложностью <math>O(cMd)</math> расчета расстояний, вычисления центроидов и проверки условия останова). Итого общая сложность алгоритма <math>O(c^2 Mdn_{iter} )</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*n_{iter} </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^2n_{iter} } \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-19T14:56:16Z

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

{{Assignment|Coctic}}

{{algorithm
| name = Нечеткий алгоритм C средних
| serial_complexity = <math>O(Mdc^2n_{iter} )</math>, <math>n_{iter} </math> - количество итераций
| input_data = <math>M*d</math>, [количество наблюдений * размерность]
| output_data = <math>M*c</math>, [количество наблюдений * количество кластеров]
| pf_height = <math>2n_{iter} </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>m = 1</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>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> n_{iter} </math>. Так как число итераций заранее неизвестно и зависит от входных параметров, рассмотрим сложность на каждой итерации. Наибольшую сложность представляет собой пересчет матрицы, сложность которого <math>O(c^2 Md)</math> (по сравнению со сложностью <math>O(cMd)</math> расчета расстояний, вычисления центроидов и проверки условия останова). Итого общая сложность алгоритма <math>O(c^2 Mdn_{iter} )</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*n_{iter} </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-19T14:55:32Z

Gkhazeeva:

{{Assignment|Coctic}}

{{algorithm
| name = Нечеткий алгоритм C средних
| serial_complexity = <math>O(Mdc^2n_{iter} )</math>, <math>n_{iter} </math> - количество итераций
| input_data = <math>M*d</math>, [количество наблюдений * размерность]
| output_data = <math>M*c</math>, [количество наблюдений * количество кластеров]
| pf_height = <math>2n_{iter} </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>m = 1</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>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> n_{iter} </math>. Так как число итераций заранее неизвестно и зависит от входных параметров, рассмотрим сложность на каждой итерации. Наибольшую сложность представляет собой пересчет матрицы, сложность которого <math>O(c^2 Md)</math> (по сравнению со сложностью <math>O(cMd)</math> расчета расстояний, вычисления центроидов и проверки условия останова). Итого общая сложность алгоритма <math>O(c^2 Mdn_{iter} )</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-19T14:51:49Z

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

{{Assignment|Coctic}}

{{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>m = 1</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>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> n_{iter} </math>. Так как число итераций заранее неизвестно и зависит от входных параметров, рассмотрим сложность на каждой итерации. Наибольшую сложность представляет собой пересчет матрицы, сложность которого <math>O(c^2 Md)</math> (по сравнению со сложностью <math>O(cMd)</math> расчета расстояний, вычисления центроидов и проверки условия останова). Итого общая сложность алгоритма <math>O(c^2 Mdn_{iter} )</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-19T14:50:55Z

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

{{Assignment|Coctic}}

{{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>m = 1</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>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> i </math>. Так как число итераций заранее неизвестно и зависит от входных параметров, рассмотрим сложность на каждой итерации. Наибольшую сложность представляет собой пересчет матрицы, сложность которого <math>O(c^2 Md)</math> (по сравнению со сложностью <math>O(cMd)</math> расчета расстояний, вычисления центроидов и проверки условия останова). Итого общая сложность алгоритма <math>O(c^2 Mdi)</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-19T14:49:41Z

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

{{Assignment|Coctic}}

{{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>m = 1</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>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 Md)</math> (по сравнению со сложностью <math>O(cMd)</math> расчета расстояний, вычисления центроидов и проверки условия останова). Итого общая сложность алгоритма <math>O(c^2 Mdi)</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

2016-12-19T14:38:08Z

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

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

* n используется без определения. Что это такое? [[Участник:Chalker|Chalker]] ([[Обсуждение участника:Chalker|обсуждение]]) 09:27, 19 декабря 2016 (MSK)

----

* M, d, c — не входят в ширину-высоту формы никаким образом? [[Участник:Chalker|Chalker]] ([[Обсуждение участника:Chalker|обсуждение]]) 19:46, 17 декабря 2016 (MSK)
* 1.1 — что такое «экспоненциальный вес» и зачем он нужен? [[Участник:Chalker|Chalker]] ([[Обсуждение участника:Chalker|обсуждение]]) 19:55, 17 декабря 2016 (MSK)
* 1.1 — «проблему объектов» — кластеризации? [[Участник:Chalker|Chalker]] ([[Обсуждение участника:Chalker|обсуждение]]) 19:46, 17 декабря 2016 (MSK)
* 1.1 — «пока … и предыдущем шаге алгоритма будут отличать» — «пока … не будут отличаться», иначе не согласовано. [[Участник:Chalker|Chalker]] ([[Обсуждение участника:Chalker|обсуждение]]) 19:46, 17 декабря 2016 (MSK)
* d определён только в 1.9, но используется везде. [[Участник:Chalker|Chalker]] ([[Обсуждение участника:Chalker|обсуждение]]) 19:46, 17 декабря 2016 (MSK)
* 1.2 — первое использование Xᵢ происходит до его определения. [[Участник:Chalker|Chalker]] ([[Обсуждение участника:Chalker|обсуждение]]) 19:46, 17 декабря 2016 (MSK)
* 1.2 — какая норма используется? [[Участник:Chalker|Chalker]] ([[Обсуждение участника:Chalker|обсуждение]]) 19:46, 17 декабря 2016 (MSK)
* 1.4 — «Генерация случайной матрицы размера M на где c, проверка условий» — что имеется ввиду? Смысл не ясен. Матрицы M * c? [[Участник:Chalker|Chalker]] ([[Обсуждение участника:Chalker|обсуждение]]) 19:46, 17 декабря 2016 (MSK)
* 1.6 — в терминах каких операций измеряется сложность? [[Участник:Chalker|Chalker]] ([[Обсуждение участника:Chalker|обсуждение]]) 19:46, 17 декабря 2016 (MSK)
* 1.6 — «пересчёт матрицы», если это 1.2.5, от d не зависит, судя по приведённой формуле. Непонятно, откуда взята сложность O(Mc²d). [[Участник:Chalker|Chalker]] ([[Обсуждение участника:Chalker|обсуждение]]) 19:46, 17 декабря 2016 (MSK)
* 1.6 — что такое «n»? Возможно, M? [[Участник:Chalker|Chalker]] ([[Обсуждение участника:Chalker|обсуждение]]) 19:46, 17 декабря 2016 (MSK)
* 1.6 — что такое «i»? В следующем пункте это номер потока. Надо привести обозначения в порядок. [[Участник:Chalker|Chalker]] ([[Обсуждение участника:Chalker|обсуждение]]) 19:46, 17 декабря 2016 (MSK)
* 1.7 — плохо описано распараллеливание. «M параллельных операций» — нужно количество потоков по числу объектов? Дальше вы совершаете сложение, которое, судя по тексту, выполняется в одном процессе в таком виде имеет сложность O(c*d*M). Так и должно быть? [[Участник:Chalker|Chalker]] ([[Обсуждение участника:Chalker|обсуждение]]) 19:55, 17 декабря 2016 (MSK)
* 1.8 — параллельная сложность не зависит от размерности векторов? [[Участник:Chalker|Chalker]] ([[Обсуждение участника:Chalker|обсуждение]]) 19:46, 17 декабря 2016 (MSK)
* 1.10 — формулировки странные, требует вычитки. «С учётом, если». Опечатки («интерации»). [[Участник:Chalker|Chalker]] ([[Обсуждение участника:Chalker|обсуждение]]) 19:46, 17 декабря 2016 (MSK)
* 1.10 — что такое «соотношение форм алгоритма»? [[Участник:Chalker|Chalker]] ([[Обсуждение участника:Chalker|обсуждение]]) 19:46, 17 декабря 2016 (MSK)
* 2.4 — не понятно, что конкретно стоит за цифрами. Их стоит описать в виде формул и определить используемые обозначения. [[Участник:Chalker|Chalker]] ([[Обсуждение участника:Chalker|обсуждение]]) 19:46, 17 декабря 2016 (MSK)

----

* Не указан вклад каждого автора [[Участник: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|Павел Юшин]]
**** Не вижу никакого противоречия с тем, что я написал в замечании [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 10:47, 7 ноября 2016 (MSK)
**** Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 16:34, 13 ноября 2016 (MSK)

----
* п. 2.4. Приведен график зависимости эффективности от параметров задачи. Не указано, о какой конкретно эффективности идет речь. [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 10:29, 17 ноября 2016 (MSK)
** Была ссылка в справочный раздел с описанием эффективности
** Подпись под рисункам должна быть самодостаточна, без необходимости разбираться, куда была ссылка и какую ссылку искать. То же касается текста: он должен быть понятен без необходимости ходить по ссылкам, ссылки - средство предоставить дополнительную информацию, для уточнения деталей. [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 16:31, 18 ноября 2016 (MSK)
** Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 10:24, 21 ноября 2016 (MSK)
* Необходимо указать характеристики программно-аппаратной платформы (какой компилятор, с какими опциями использовался, какие версии библиотек, на каких узлах проводился запуск и т.д.) [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 10:24, 21 ноября 2016 (MSK)
** Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 15:24, 22 ноября 2016 (MSK)

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

2016-12-19T14:36:55Z

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

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

* n используется без определения. Что это такое? [[Участник:Chalker|Chalker]] ([[Обсуждение участника:Chalker|обсуждение]]) 09:27, 19 декабря 2016 (MSK)

----

* M, d, c — не входят в ширину-высоту формы никаким образом? [[Участник:Chalker|Chalker]] ([[Обсуждение участника:Chalker|обсуждение]]) 19:46, 17 декабря 2016 (MSK)
* 1.1 — что такое «экспоненциальный вес» и зачем он нужен? [[Участник:Chalker|Chalker]] ([[Обсуждение участника:Chalker|обсуждение]]) 19:55, 17 декабря 2016 (MSK)
* 1.1 — «проблему объектов» — кластеризации? [[Участник:Chalker|Chalker]] ([[Обсуждение участника:Chalker|обсуждение]]) 19:46, 17 декабря 2016 (MSK)
* 1.1 — «пока … и предыдущем шаге алгоритма будут отличать» — «пока … не будут отличаться», иначе не согласовано. [[Участник:Chalker|Chalker]] ([[Обсуждение участника:Chalker|обсуждение]]) 19:46, 17 декабря 2016 (MSK)
* d определён только в 1.9, но используется везде. [[Участник:Chalker|Chalker]] ([[Обсуждение участника:Chalker|обсуждение]]) 19:46, 17 декабря 2016 (MSK)
** d определен в пункте 1.2 при описании входных параметров Х
* 1.2 — первое использование Xᵢ происходит до его определения. [[Участник:Chalker|Chalker]] ([[Обсуждение участника:Chalker|обсуждение]]) 19:46, 17 декабря 2016 (MSK)
* 1.2 — какая норма используется? [[Участник:Chalker|Chalker]] ([[Обсуждение участника:Chalker|обсуждение]]) 19:46, 17 декабря 2016 (MSK)
* 1.4 — «Генерация случайной матрицы размера M на где c, проверка условий» — что имеется ввиду? Смысл не ясен. Матрицы M * c? [[Участник:Chalker|Chalker]] ([[Обсуждение участника:Chalker|обсуждение]]) 19:46, 17 декабря 2016 (MSK)
* 1.6 — в терминах каких операций измеряется сложность? [[Участник:Chalker|Chalker]] ([[Обсуждение участника:Chalker|обсуждение]]) 19:46, 17 декабря 2016 (MSK)
* 1.6 — «пересчёт матрицы», если это 1.2.5, от d не зависит, судя по приведённой формуле. Непонятно, откуда взята сложность O(Mc²d). [[Участник:Chalker|Chalker]] ([[Обсуждение участника:Chalker|обсуждение]]) 19:46, 17 декабря 2016 (MSK)
* 1.6 — что такое «n»? Возможно, M? [[Участник:Chalker|Chalker]] ([[Обсуждение участника:Chalker|обсуждение]]) 19:46, 17 декабря 2016 (MSK)
* 1.6 — что такое «i»? В следующем пункте это номер потока. Надо привести обозначения в порядок. [[Участник:Chalker|Chalker]] ([[Обсуждение участника:Chalker|обсуждение]]) 19:46, 17 декабря 2016 (MSK)
* 1.7 — плохо описано распараллеливание. «M параллельных операций» — нужно количество потоков по числу объектов? Дальше вы совершаете сложение, которое, судя по тексту, выполняется в одном процессе в таком виде имеет сложность O(c*d*M). Так и должно быть? [[Участник:Chalker|Chalker]] ([[Обсуждение участника:Chalker|обсуждение]]) 19:55, 17 декабря 2016 (MSK)
* 1.8 — параллельная сложность не зависит от размерности векторов? [[Участник:Chalker|Chalker]] ([[Обсуждение участника:Chalker|обсуждение]]) 19:46, 17 декабря 2016 (MSK)
* 1.10 — формулировки странные, требует вычитки. «С учётом, если». Опечатки («интерации»). [[Участник:Chalker|Chalker]] ([[Обсуждение участника:Chalker|обсуждение]]) 19:46, 17 декабря 2016 (MSK)
* 1.10 — что такое «соотношение форм алгоритма»? [[Участник:Chalker|Chalker]] ([[Обсуждение участника:Chalker|обсуждение]]) 19:46, 17 декабря 2016 (MSK)
* 2.4 — не понятно, что конкретно стоит за цифрами. Их стоит описать в виде формул и определить используемые обозначения. [[Участник:Chalker|Chalker]] ([[Обсуждение участника:Chalker|обсуждение]]) 19:46, 17 декабря 2016 (MSK)

----

* Не указан вклад каждого автора [[Участник: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|Павел Юшин]]
**** Не вижу никакого противоречия с тем, что я написал в замечании [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 10:47, 7 ноября 2016 (MSK)
**** Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 16:34, 13 ноября 2016 (MSK)

----
* п. 2.4. Приведен график зависимости эффективности от параметров задачи. Не указано, о какой конкретно эффективности идет речь. [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 10:29, 17 ноября 2016 (MSK)
** Была ссылка в справочный раздел с описанием эффективности
** Подпись под рисункам должна быть самодостаточна, без необходимости разбираться, куда была ссылка и какую ссылку искать. То же касается текста: он должен быть понятен без необходимости ходить по ссылкам, ссылки - средство предоставить дополнительную информацию, для уточнения деталей. [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 16:31, 18 ноября 2016 (MSK)
** Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 10:24, 21 ноября 2016 (MSK)
* Необходимо указать характеристики программно-аппаратной платформы (какой компилятор, с какими опциями использовался, какие версии библиотек, на каких узлах проводился запуск и т.д.) [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 10:24, 21 ноября 2016 (MSK)
** Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 15:24, 22 ноября 2016 (MSK)

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

2016-12-19T14:36:23Z

Gkhazeeva: Новая страница: «d определен в пункте 1.2 при описании входных параметров Х»

d определен в пункте 1.2 при описании входных параметров Х

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

2016-12-19T14:35:08Z

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

{{Assignment|Coctic}}

{{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>m = 1</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>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-19T14:34:34Z

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

{{Assignment|Coctic}}

{{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>m = 1</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>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-11-21T20:02:05Z

Gkhazeeva:

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

'''Операция 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-21T20:01:24Z

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

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

'''Операция 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-21T19:54:58Z

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

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

'''Операция 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 . Расчеты проводились на узлах с процессорами Intel Xeon X5670 2.93GHz.

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

* число процессоров [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-18T19:41:17Z

Gkhazeeva:

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

'''Операция 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 Суперкомпьютерного комплекса Московского университета].

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

* число процессоров [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-18T19:39:32Z

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

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

'''Операция 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 Суперкомпьютерного комплекса Московского университета].

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

* число процессоров [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-18T13:19:13Z

Gkhazeeva:

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

'''Операция 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 Суперкомпьютерного комплекса Московского университета].

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

* число процессоров [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

2016-11-18T13:18:52Z

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

= Статья [[Нечеткий алгоритм 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|Павел Юшин]]
**** Не вижу никакого противоречия с тем, что я написал в замечании [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 10:47, 7 ноября 2016 (MSK)
**** Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 16:34, 13 ноября 2016 (MSK)

----
* п. 2.4. Приведен график зависимости эффективности от параметров задачи. Не указано, о какой конкретно эффективности идет речь. [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 10:29, 17 ноября 2016 (MSK)
** Была ссылка в справочный раздел с описанием эффективности

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

2016-11-18T13:18:37Z

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

= Статья [[Нечеткий алгоритм 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|Павел Юшин]]
**** Не вижу никакого противоречия с тем, что я написал в замечании [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 10:47, 7 ноября 2016 (MSK)
**** Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 16:34, 13 ноября 2016 (MSK)

----
* п. 2.4. Приведен график зависимости эффективности от параметров задачи. Не указано, о какой конкретно эффективности идет речь. [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 10:29, 17 ноября 2016 (MSK)
** Был ссылка в справочный раздел с описанием эффективности

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

2016-11-18T13:15:18Z

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

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

'''Операция 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 Суперкомпьютерного комплекса Московского университета].

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

* число процессоров [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-16T18:25:52Z

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

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

'''Операция 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 Суперкомпьютерного комплекса Московского университета].

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

* число процессоров [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-16T18:25:35Z

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

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

'''Операция 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 Суперкомпьютерного комплекса Московского университета].

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

* число процессоров [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-16T18:24:36Z

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

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

'''Операция 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 Суперкомпьютерного комплекса Московского университета].

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

* число процессоров [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-16T18:22:57Z

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

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

'''Операция 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 Суперкомпьютерного комплекса Московского университета].

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

* число процессоров [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-13T19:46:25Z

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

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

'''Операция 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 Суперкомпьютерного комплекса Московского университета].

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

* число процессоров [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. При рассмотрении увеличения как вычислительной сложности, так и числа процессов на всей рассмотренной области значений эффективность увеличивается, однако скорость увеличения эффективности небольшая.

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

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

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

* Реализация алгоритма на 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-13T19:45:25Z

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

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

'''Операция 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 Суперкомпьютерного комплекса Московского университета].

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

* число процессоров [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. При рассмотрении увеличения как вычислительной сложности, так и числа процессов на всей рассмотренной области значений эффективность увеличивается, однако скорость увеличения эффективности небольшая.

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

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

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

* Реализация алгоритма на 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-13T19:45:05Z

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

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

'''Операция 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 Суперкомпьютерного комплекса Московского университета].

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

* число процессоров [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. При рассмотрении увеличения как вычислительной сложности, так и числа процессов на всей рассмотренной области значений эффективность увеличивается, однако скорость увеличения эффективности небольшая.

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

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

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

* Реализация алгоритма на 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-13T19:41:45Z

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

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

'''Операция 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 Суперкомпьютерного комплекса Московского университета].

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

* число процессоров [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. При рассмотрении увеличения как вычислительной сложности, так и числа процессов на всей рассмотренной области значений эффективность увеличивается, однако скорость увеличения эффективности небольшая.

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

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

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

* Реализация алгоритма на 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-13T15:59:55Z

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

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

'''Операция 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 Суперкомпьютерного комплекса Московского университета].

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

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

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

* минимальная эффективность реализации 3,8%;
* максимальная эффективность реализации 83,1%.

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

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

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

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

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

* Реализация алгоритма на 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-13T15:49:34Z

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

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

2016-11-13T15:46:58Z

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

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

2016-11-13T15:45:07Z

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

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

2016-11-11T10:11:48Z

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

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

2016-10-31T19:46:41Z

Gkhazeeva:

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

2016-10-31T19:45:00Z

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

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

2016-10-14T19:23:45Z

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

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

2016-10-14T19:23:17Z

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

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

2016-10-14T19:22:40Z

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

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

2016-10-13T19:49:17Z

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

{{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-13T19:45:35Z

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

{{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<C; 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-13T19:45:15Z

Gkhazeeva:

{{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<C; 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-13T19:41:35Z

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

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

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

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

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

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

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

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

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

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