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

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

2016-12-19T23:54:54Z

Protsenko: /* Замечания по тексту */

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

=== Замечания по тексту ===

* 1.8 — Непонятна схема распараллеливания для такой оценки сложности. У вас C*K процессов? [[Участник:Chalker|Chalker]] ([[Обсуждение участника:Chalker|обсуждение]]) 22:43, 17 декабря 2016 (MSK)

В самом лучшем случае, для вычисления суммы n чисел нам потребуется выполнить <math>\log_{2} </math>сложений. (Каскадная схема). Это описан самый быстрый из существующих способ.

В MPI используем K процессов (так как количество процессов ограничено, то на один процесс может выделяться больше одного вектора) и каждый процесс по отдельности обрабатывает свои вектора с использование OpenMP.

* 1.8 — Даже эту формулу можно записать проще по тривиальным свойствам логарифма. [[Участник:Chalker|Chalker]] ([[Обсуждение участника:Chalker|обсуждение]]) 22:43, 17 декабря 2016 (MSK)

Данная формула была приведена в таком виде что бы показать соотношение влияния количества кластеров и количества векторов на сложность алгоритма. Можем упростить ее, если так лучше.

* 1.8 — Схема распараллеливания должна быть описана более детально. [[Участник:Chalker|Chalker]] ([[Обсуждение участника:Chalker|обсуждение]]) 22:43, 17 декабря 2016 (MSK)

Описали схему подробнее.

* Сложность не зависит от N? В оценке сложности не учтена размерность входных векторов. [[Участник:Chalker|Chalker]] ([[Обсуждение участника:Chalker|обсуждение]]) 20:14, 17 декабря 2016 (MSK)

Исправлено.

* 1.6 — в терминах каких операций измеряется сложность? [[Участник:Chalker|Chalker]] ([[Обсуждение участника:Chalker|обсуждение]]) 20:14, 17 декабря 2016 (MSK)

Подсчитаны операции умножения и деления.
В разделе "вычисление центров кластеров" будет C*K умножений для вычисления числителя. (Деление числителя на знаменатель будет выполняться С раз, что на порядок меньше).
Для раздела "вычисление решающей функции" посчитано количество умножений C*K раз. (Деления в этом разделе нет)
Для обновления матрицы посчитано количество операций деления С*C*K (Порядок у деления m[i,k]=1/m[i,k] ниже)

* 2.4 — я не совсем понимаю, на какой именно конфигурации выполнялся анализ масштабируемости. Там написано, что используется OpenMP (для систем с общей памятью), суперкомпьютер Ломоносов, а количество процессоров доходит до 120. Я не вижу таких узлов в Ломоносове в его описании [http://parallel.ru/cluster/lomonosov.html]. Можете пояснить? [[Участник:Chalker|Chalker]] ([[Обсуждение участника:Chalker|обсуждение]]) 18:31, 5 декабря 2016 (MSK)

Запускали в тестовой очереди. В тексте допустили неточность, для передачи данных данных использовали MPI. Запустили еще раз, номер node1-130-[01-16]. 120- количество потоков.

** Текст до сих пор не исправлен, в приведённой реализации тоже используется OpenMP, а не MPI. Если используется она — то это запускается на одном узле. Данные точно верны? [[Участник:Chalker|Chalker]] ([[Обсуждение участника:Chalker|обсуждение]]) 20:14, 17 декабря 2016 (MSK)

Исправили текст.
В MPI используем K процессов (так как количество процессов ограничено, то на один процесс может выделяться больше одного вектора) и каждый процесс по отдельности обрабатывает свои вектора с использование OpenMP.
В зависимости от номера процесса определяется какие вектора он будет обрабатывать. Каждый процесс обрабатывает свои вектора, а потом собирается общий результат.
----

* В разделе 1.5 кроме текста программы нужны словесные пояснения. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 16:38, 27 октября 2016 (MSK)
* Граф, представленный в разделе 1.7, не является информационным графом (ациклический граф, вершины - операции, дуги - информационные зависимости). [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 16:38, 27 октября 2016 (MSK)
** Приведённый граф по-прежнему является графом управления, а не информационным графом: содержит цикл, ветвление и т.д. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 11:31, 1 ноября 2016 (MSK)

* В разделе 1.9 требуется привести оценки объёма входных и выходных данных. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 16:38, 27 октября 2016 (MSK)

* Подписи к рисунку в разделе 2.4 крайне мелкие, почти неразличимые. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 15:19, 16 ноября 2016 (MSK)
* В разделе 2.4 не приведены все параметры запуска теста - какой компилятор, с какими опциями использовался, какие версии библиотек, на каких узлах проводился запуск и т.д. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 15:19, 16 ноября 2016 (MSK)
* В разделе 2.4 не приведена использованная в экспериментах реализация алгоритма. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 15:19, 16 ноября 2016 (MSK)
* Рисунки в статье не пронумерованы. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 14:04, 21 ноября 2016 (MSK)
* Из графиков в разделе 2.4 следует сделать выводы о масштабируемости реализации. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 14:04, 21 ноября 2016 (MSK)

Исправлено

Граф исправлен еще раз

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

2016-12-19T23:54:08Z

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

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

=== Замечания по тексту ===

* 1.8 — Непонятна схема распараллеливания для такой оценки сложности. У вас C*K процессов? [[Участник:Chalker|Chalker]] ([[Обсуждение участника:Chalker|обсуждение]]) 22:43, 17 декабря 2016 (MSK)

В самом лучшем случае, для вычисления суммы n чисел нам потребуется выполнить <math>log _{2} n<\math> сложений. (Каскадная схема). Это описан самый быстрый из существующих способ.

В MPI используем K процессов (так как количество процессов ограничено, то на один процесс может выделяться больше одного вектора) и каждый процесс по отдельности обрабатывает свои вектора с использование OpenMP.

* 1.8 — Даже эту формулу можно записать проще по тривиальным свойствам логарифма. [[Участник:Chalker|Chalker]] ([[Обсуждение участника:Chalker|обсуждение]]) 22:43, 17 декабря 2016 (MSK)

Данная формула была приведена в таком виде что бы показать соотношение влияния количества кластеров и количества векторов на сложность алгоритма. Можем упростить ее, если так лучше.

* 1.8 — Схема распараллеливания должна быть описана более детально. [[Участник:Chalker|Chalker]] ([[Обсуждение участника:Chalker|обсуждение]]) 22:43, 17 декабря 2016 (MSK)

Описали схему подробнее.

* Сложность не зависит от N? В оценке сложности не учтена размерность входных векторов. [[Участник:Chalker|Chalker]] ([[Обсуждение участника:Chalker|обсуждение]]) 20:14, 17 декабря 2016 (MSK)

Исправлено.

* 1.6 — в терминах каких операций измеряется сложность? [[Участник:Chalker|Chalker]] ([[Обсуждение участника:Chalker|обсуждение]]) 20:14, 17 декабря 2016 (MSK)

Подсчитаны операции умножения и деления.
В разделе "вычисление центров кластеров" будет C*K умножений для вычисления числителя. (Деление числителя на знаменатель будет выполняться С раз, что на порядок меньше).
Для раздела "вычисление решающей функции" посчитано количество умножений C*K раз. (Деления в этом разделе нет)
Для обновления матрицы посчитано количество операций деления С*C*K (Порядок у деления m[i,k]=1/m[i,k] ниже)

* 2.4 — я не совсем понимаю, на какой именно конфигурации выполнялся анализ масштабируемости. Там написано, что используется OpenMP (для систем с общей памятью), суперкомпьютер Ломоносов, а количество процессоров доходит до 120. Я не вижу таких узлов в Ломоносове в его описании [http://parallel.ru/cluster/lomonosov.html]. Можете пояснить? [[Участник:Chalker|Chalker]] ([[Обсуждение участника:Chalker|обсуждение]]) 18:31, 5 декабря 2016 (MSK)

Запускали в тестовой очереди. В тексте допустили неточность, для передачи данных данных использовали MPI. Запустили еще раз, номер node1-130-[01-16]. 120- количество потоков.

** Текст до сих пор не исправлен, в приведённой реализации тоже используется OpenMP, а не MPI. Если используется она — то это запускается на одном узле. Данные точно верны? [[Участник:Chalker|Chalker]] ([[Обсуждение участника:Chalker|обсуждение]]) 20:14, 17 декабря 2016 (MSK)

Исправили текст.
В MPI используем K процессов (так как количество процессов ограничено, то на один процесс может выделяться больше одного вектора) и каждый процесс по отдельности обрабатывает свои вектора с использование OpenMP.
В зависимости от номера процесса определяется какие вектора он будет обрабатывать. Каждый процесс обрабатывает свои вектора, а потом собирается общий результат.
----

* В разделе 1.5 кроме текста программы нужны словесные пояснения. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 16:38, 27 октября 2016 (MSK)
* Граф, представленный в разделе 1.7, не является информационным графом (ациклический граф, вершины - операции, дуги - информационные зависимости). [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 16:38, 27 октября 2016 (MSK)
** Приведённый граф по-прежнему является графом управления, а не информационным графом: содержит цикл, ветвление и т.д. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 11:31, 1 ноября 2016 (MSK)

* В разделе 1.9 требуется привести оценки объёма входных и выходных данных. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 16:38, 27 октября 2016 (MSK)

* Подписи к рисунку в разделе 2.4 крайне мелкие, почти неразличимые. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 15:19, 16 ноября 2016 (MSK)
* В разделе 2.4 не приведены все параметры запуска теста - какой компилятор, с какими опциями использовался, какие версии библиотек, на каких узлах проводился запуск и т.д. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 15:19, 16 ноября 2016 (MSK)
* В разделе 2.4 не приведена использованная в экспериментах реализация алгоритма. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 15:19, 16 ноября 2016 (MSK)
* Рисунки в статье не пронумерованы. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 14:04, 21 ноября 2016 (MSK)
* Из графиков в разделе 2.4 следует сделать выводы о масштабируемости реализации. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 14:04, 21 ноября 2016 (MSK)

Исправлено

Граф исправлен еще раз

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

2016-12-19T23:53:39Z

Protsenko:

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

=== Замечания по тексту ===

* 1.8 — Непонятна схема распараллеливания для такой оценки сложности. У вас C*K процессов? [[Участник:Chalker|Chalker]] ([[Обсуждение участника:Chalker|обсуждение]]) 22:43, 17 декабря 2016 (MSK)

В самом лучшем случае, для вычисления суммы n чисел нам потребуется выполнить l <math>log _{2} n<\math> сложений. (Каскадная схема). Это описан самый быстрый из существующих способ.

В MPI используем K процессов (так как количество процессов ограничено, то на один процесс может выделяться больше одного вектора) и каждый процесс по отдельности обрабатывает свои вектора с использование OpenMP.

* 1.8 — Даже эту формулу можно записать проще по тривиальным свойствам логарифма. [[Участник:Chalker|Chalker]] ([[Обсуждение участника:Chalker|обсуждение]]) 22:43, 17 декабря 2016 (MSK)

Данная формула была приведена в таком виде что бы показать соотношение влияния количества кластеров и количества векторов на сложность алгоритма. Можем упростить ее, если так лучше.

* 1.8 — Схема распараллеливания должна быть описана более детально. [[Участник:Chalker|Chalker]] ([[Обсуждение участника:Chalker|обсуждение]]) 22:43, 17 декабря 2016 (MSK)

Описали схему подробнее.

* Сложность не зависит от N? В оценке сложности не учтена размерность входных векторов. [[Участник:Chalker|Chalker]] ([[Обсуждение участника:Chalker|обсуждение]]) 20:14, 17 декабря 2016 (MSK)

Исправлено.

* 1.6 — в терминах каких операций измеряется сложность? [[Участник:Chalker|Chalker]] ([[Обсуждение участника:Chalker|обсуждение]]) 20:14, 17 декабря 2016 (MSK)

Подсчитаны операции умножения и деления.
В разделе "вычисление центров кластеров" будет C*K умножений для вычисления числителя. (Деление числителя на знаменатель будет выполняться С раз, что на порядок меньше).
Для раздела "вычисление решающей функции" посчитано количество умножений C*K раз. (Деления в этом разделе нет)
Для обновления матрицы посчитано количество операций деления С*C*K (Порядок у деления m[i,k]=1/m[i,k] ниже)

* 2.4 — я не совсем понимаю, на какой именно конфигурации выполнялся анализ масштабируемости. Там написано, что используется OpenMP (для систем с общей памятью), суперкомпьютер Ломоносов, а количество процессоров доходит до 120. Я не вижу таких узлов в Ломоносове в его описании [http://parallel.ru/cluster/lomonosov.html]. Можете пояснить? [[Участник:Chalker|Chalker]] ([[Обсуждение участника:Chalker|обсуждение]]) 18:31, 5 декабря 2016 (MSK)

Запускали в тестовой очереди. В тексте допустили неточность, для передачи данных данных использовали MPI. Запустили еще раз, номер node1-130-[01-16]. 120- количество потоков.

** Текст до сих пор не исправлен, в приведённой реализации тоже используется OpenMP, а не MPI. Если используется она — то это запускается на одном узле. Данные точно верны? [[Участник:Chalker|Chalker]] ([[Обсуждение участника:Chalker|обсуждение]]) 20:14, 17 декабря 2016 (MSK)

Исправили текст.
В MPI используем K процессов (так как количество процессов ограничено, то на один процесс может выделяться больше одного вектора) и каждый процесс по отдельности обрабатывает свои вектора с использование OpenMP.
В зависимости от номера процесса определяется какие вектора он будет обрабатывать. Каждый процесс обрабатывает свои вектора, а потом собирается общий результат.
----

* В разделе 1.5 кроме текста программы нужны словесные пояснения. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 16:38, 27 октября 2016 (MSK)
* Граф, представленный в разделе 1.7, не является информационным графом (ациклический граф, вершины - операции, дуги - информационные зависимости). [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 16:38, 27 октября 2016 (MSK)
** Приведённый граф по-прежнему является графом управления, а не информационным графом: содержит цикл, ветвление и т.д. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 11:31, 1 ноября 2016 (MSK)

* В разделе 1.9 требуется привести оценки объёма входных и выходных данных. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 16:38, 27 октября 2016 (MSK)

* Подписи к рисунку в разделе 2.4 крайне мелкие, почти неразличимые. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 15:19, 16 ноября 2016 (MSK)
* В разделе 2.4 не приведены все параметры запуска теста - какой компилятор, с какими опциями использовался, какие версии библиотек, на каких узлах проводился запуск и т.д. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 15:19, 16 ноября 2016 (MSK)
* В разделе 2.4 не приведена использованная в экспериментах реализация алгоритма. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 15:19, 16 ноября 2016 (MSK)
* Рисунки в статье не пронумерованы. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 14:04, 21 ноября 2016 (MSK)
* Из графиков в разделе 2.4 следует сделать выводы о масштабируемости реализации. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 14:04, 21 ноября 2016 (MSK)

Исправлено

Граф исправлен еще раз

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

2016-12-19T23:52:20Z

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

{{Assignment|ASA}}

{{algorithm
| name = Нечеткий алгоритм C средних
| serial_complexity = <math>O(C*C*K*N*I)</math>., где <math>I</math> - количество итераций
| input_data = <math>K*N</math>, [количество векторов * размерность]
| output_data = <math>C*K</math>, [элементы матрицы принадлежности]
| pf_height = <math>3I</math>
| pf_width = <math>C*C*K</math>
}}

Авторы : [[Участник:Protsenko|Мария Проценко]] (1.5-1.8, 2.7), [[Участник:ADovganich|Андрей Довганич]] (1.1-1.4, 1.9, 1.10)

= Свойства и структура алгоритмов =
== Общее описание алгоритма ==
Нечеткий алгоритм C-средних (fuzzy C-means) позволяет разбить имеющееся множество векторов (точек) мощностью <math>K</math> на заданное число нечетких множеств. Предназначен для кластеризации больших наборов данных. Основным достоинством алгоритма является нечеткость при определении объекта в кластер. Благодаря этому становится возможным определить объекты, которые находятся на границе, в кластеры. Из основного достоинства следует и главный недостаток - неопределенность с объектами, удаленными от центров всех кластеров. В остальном ему присущи стандартные проблемы подобного класса алгоритмов: вычислительная сложность, необходимость задания количества кластеров<ref>Нейский И.М. Классификация и сравнение методов кластеризации</ref>.

Алгоритм был разработан J.C. Dunn в 1973 г.<ref> Dunn, J. C. (1973-01-01). "A Fuzzy Relative of the ISODATA Process and Its Use in Detecting Compact Well-Separated Clusters". Journal of Cybernetics. 3 (3): 32–57. doi:10.1080/01969727308546046. ISSN 0022-0280.</ref>, усовершенствован J.C. Bezdek в 1981 г.<ref> Bezdek, James C. (1981). Pattern Recognition with Fuzzy Objective Function Algorithms. ISBN 0-306-40671-3.</ref>.

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

В общем виде алгоритм можно записать следующим образом:

# Инициализировать матрицу принадлежности;
# Вычислить центры кластеров;
# Вычислить значение решающей функции. Если значение ниже некоторого порогового или его улучшение по сравнению с предыдущей итерацией меньше определенной величины, то остановить вычисления;
# Иначе вычислить новые значения матрицы принадлежности;
# Перейти к шагу 2

== Математическое описание алгоритма ==
Рассмотрим матрицу <math> M = m_{ik} \in[0,1],\; i = 1, ..., c, \; k = 1, ..., K </math>. <math>m_{i,k}</math> - вероятность принадлежности объекта <math>k</math> к кластеру <math>i</math>; <math>c</math> - количество кластеров, <math>K</math> - количество векторов. При этом элементы матрицы удовлетворяют следующим условиям:

* сумма элементов в каждом столбце равна <math>1</math>;

* сумма всех элементов матрицы равно <math>K</math>;

Назовем <math> M </math> матрицей принадлежности.

Пусть <math>c_{i} (i = 1,2,...c)</math> - центры кластеров. Тогда рассмотрим функцию

<math>
\begin{align}
J(M, c_{1}, c_{2},...c_{c}) = \sum_{i = 1}^{c}{J_{i}} = \sum_{i = 1}^{c}\sum_{k = 1}^{K}{m_{ik}^q}d_{ik}^2 ~(1)
\end{align}
</math>

где <math> d_{ik} = \left\Vert{u_{k}-c_{i}}\right\| </math> - Евклидово расстояние между центром кластера и объектом, <math> 1 \le q \le \infty </math> - экспоненциальный весовой коэффициент, характеризующий нечеткость. Будем минимизировать значение функции <math> J </math>. Для этого вычислим центры кластеров по формуле <math> ~(2) </math>.

<math>c_{i} = {{\sum_{k = 1}^{K}{m_{ik}^q} * u_{k}} \over {\sum_{k = 1}^{K}{m_{ik}^q}}}~(2)</math>

где <math>m_{ik}</math> — коэффициент принадлежности <math>u_{k}</math> вектора к кластеру <math>c_{i}</math>

и новые значения матрицы <math> M </math> по формуле <math> ~(3) </math>

<math>m_{ik} = {1 \over \sum_{j = 1}^{c}{({{d_{ik}} \over {d_{jk}}})}^{2 \over q-1}} ~(3)</math>

<math> ~(2) </math> и <math> ~(3) </math>являются необходимым условиями достижения минимума функцией <math> J </math>. Таким образом эти два условия дают нам итерационный процесс.

Полностью алгоритм можно записать следующим образом:

# Инициализировать матрицу принадлежности <math> M </math> случайными значениями от 0 до 1;
# Вычислить центры кластеров <math>c_{i} (i = 1,2,...c)</math> используя формулу <math>~(2)</math>;
# Вычислить значение решающей функции по формуле <math>~(1)</math>. Если значение <math> J < \varepsilon,~\varepsilon > 0</math> или <math> |J_{i} - J_{i-1}| < \delta,~\delta > 0 </math>, то остановить вычисления;
# Иначе вычислить новые значения матрицы М по формуле <math>~(3)</math>;
# Перейти к шагу 2

== Вычислительное ядро алгоритма ==
Вычислительным ядром алгоритма являются формулы: <math> (1) </math>, <math> (2) </math>, <math> (3) </math>. В них производится вычисление новых центров кластеров, значения решающей функции и пересчет элементов матрицы принадлежности.

== Макроструктура алгоритма ==
Макроструктура алгоритма состоит из следующих шагов:

# Инициализация матрицы <math> M </math> случайными значениями от 0 до 1;
# Вычисление центров кластеров;
# Вычисление значения решающей функции(если оно удовлетворяет условиям останова - завершение вычислений);
# Вычисление новых элементов матрицы принадлежности;
# Переход к шагу 2;

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

Пример реализации алгоритма на языке С++. Сначала вычислим центры кластеров, потом вычислим решающую функцию, с ее помощью определим необходимость продолжать алгоритм, и при необходимости вычислим новые значения матрицы M.
<source lang="C++">

float ** m;
int *c;
int number_clusters, number_items;
m = gen_random_clusters();//заполним матрицу m случайными значениями от 0 до 1

while (true)
{
//вычисление центров кластеров
for (int i=0; i<number_clusters; i++)
{
numerator==denumerator=0;
for (int k=0; k<number_items; k++)
{
numerator+=pow(m[i, k], q)*u[k];//u[k]-вектор
denumerator+=pow(m[i, k], q);
}
c[i]= numerator / denumerator;//центры кластеров
}

j=0;//вычисление решающей функции
for (int i=0; i<number_clusters; i++)
for (int k=0; k<number_items; k++)
j+=pow(m[i, k], q)*pow(dist(c[i], x[k],2);//dist-вычисляет расстояние между заданными векторами

if ((abs(j-last_j)<delta) || (j<eps)) break;//проверка на необходимость завернешения алгоритма
last_j=j;
//обновление матрицы m
for (int i=0; i<number_clusters; i++)
for (int k=0; k<number_items; k++)
{
m[i,k]=0
for(int j=0; j<number_clusters; j++)
m[i,k]+=pow(dist(c[i], x[k])/dist(c[j], x[k]),2/(q-1));
m[i,k]=1/m[i,k];
}

}
</source>

== Последовательная сложность алгоритма ==
Каждая итерация включает в себя
* Вычисление центров кластеров <math>O(C*K)</math>
* Вычисление решающей функции <math>O(C*K)</math>
* Обновлене матрицы <math>M</math> <math>O(C*C*K)</math>
Общая сложность каждой итерации <math>O(C*C*K)</math>.

Сложность всего алгоритма будет зависеть от числа итераций, которое зависит от
* Выбора начального приближения
* Выбора условий останова

Окончательно, сложность алгоритма будет равна произведению количества итераций на их сложность

== Информационный граф ==
'''Первый ярус''' состоит из <math>C</math> параллельных операций, каждая их которых в свою очередь состоит из <math>K</math> параллельных операций, и одной, которая выполняется с использованием результата предыдущих.
Результатом работы этого яруса являются значения центров кластеров , которые будут использоваться на следующем ярусе.

'''Второй ярус''' содержит в себе <math>C*K</math> параллельных операций.
Результатом его работы является значение решающей функции <math>J</math>. Её значение определяет необходимость завершения алгоритма.

'''Третий ярус''' включает <math>C*K</math> параллельных операций, каждая из которых состоит из <math>C</math> параллельных операций, и одной, которая выполняется с использованием результата предыдущих.

[[Файл:Суперпрак.png|1200px|thumb|center|Рисунок 1 Информационный граф алгоритма. Салатовым цветом обозначены вершины графа-операции. Дугами обозначена передача информации, передаваемые данные надписаны сверху.]]

== Ресурс параллелизма алгоритма ==
На каждом шаге алгоритма необходимо вычислять сумму элементов массивов. Будем считать, что количество процессоров у нас стремится к бесконечности. Поэтому каждую операцию умножения и деления на данном шаге можно выполнять отдельно, сложность будет составлять только суммирование полученных результатов. Для суммирования применим каскадную схему.

Сложность ее вычисления на первом шаге (вычисление центров кластеров) при параллельной реализации составляет <math>O(\log_{2}N*C)</math>. Для каждого элемента из набора входных данных(<math> K * N </math>). Здесь возможен независимый расчет(координатный параллелизм).

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

На третьем шаге имеем сложность <math>O(\log_{2} N*K*C^2)</math>. Что видно из последовательной реализации в п.1.5.

Итого суммарная сложность итерации: <math>O(\log_{2} {C*K*N} + \log_{2} K^2N^2*C^3)</math>. Воспользовавшись свойствами логарифма произведения получаем: <math>O(\log_{2} {K^3*N^3} + \log_{2} C^4)</math>.

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

== Входные и выходные данные алгоритма ==
Входные данные:
* <math>u_{k} ~k = 1, ..., K</math> - набор входных векторов размерности <math> N </math>;
* <math>C</math> - количество кластеров;
* <math>q</math> - экспоненциальный весовой коэффициент, характеризующий нечеткость;
* <math>\varepsilon > 0, ~\delta > 0</math> - коэффициенты, описывающие точность алгоритма.
Объем входных данных: <math> K*N </math>

Выходные данные:
* <math> M </math> - матрица принадлежности.
Объем выходных данных: <math> C*K </math>

== Свойства алгоритма ==
*Соотношение последовательной и параллельной сложности алгоритма: <math>C*C*K \over {\log_{2} {K} + \log_{2} C^4}</math>. Соответственно при распараллеливании наибольший прирост в производительности мы получим при разбиении большого набора данных на большее число кластеров;
*Вычислительная мощность: <math>{{C^2*K} \over {C*K}} = C</math>. Получается, что на чем большее количество кластеров мы разбиваем набор данных, тем менее затратным становится перемещение данных;
*Алгоритм не является устойчивым, как и другие подобные алгоритмы этого класса(например k-means). Очень многое зависит как от входных данных, так и от изначальных параметров приближения(заполнения матрицы принадлежности => исходных центров кластеров);
*Не является детерминированным. Так же очень многое зависит как от входных данных, так и от изначальных параметров приближения(заполнения матрицы принадлежности => исходных центров кластеров);
*Алгоритм не сбалансирован - доминирует операция умножения. Параллельные ветви алгоритма сбалансированы;
*Степень исхода вершины информационного графа - 2.

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

Проведём исследование масштабируемости параллельной реализации разложения Холецкого согласно [[Scalability methodology|методике]]. Исследование проводилось на суперкомпьютере "Ломоносов"<ref name="Lom">Воеводин Вл., Жуматий С., Соболев С., Антонов А., Брызгалов П., Никитенко Д., Стефанов К., Воеводин Вад. Практика суперкомпьютера «Ломоносов» // Открытые системы, 2012, N 7, С. 36-39.</ref> [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета].

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

* число процессоров [1 : 120];
* размер входных данных [1 : 15 000] векторов размерности 4.
При количестве кластеров 100.

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

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

В параллельной реализации использовалась технология OpenMP, для передачи данных данных между потоками использовалась технология MPI. Компилятор GNU(gcc) с флагом -fopenmp. Версия компилятора: gcc version 4.4.7 20120313 (Red Hat 4.4.7-4) (GCC).

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

[[file: FCM произв.jpg |thumb|center|800px|Рисунок 2 Изменение производительности.]]

[[file: FCM эф.jpg |thumb|center|800px|Рисунок 3 Изменение эффективности.]]

Оценки масштабируемости:
* По числу процессов: 0.1245.
* По размеру задачи: -0.0278.
* По двум направлениям: 0,00009.

[http://pastebin.com/LDPNY5Ua Параллельная реализация на языке С с использованием Open MP]

== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Можно найти следующие реализации алгоритма
* Для MATLAB http://www.mathworks.com/help/fuzzy/fcm.html
* В PostgreSQL http://num-meth.srcc.msu.ru/zhurnal/tom_2012/v13r207.html
Так же готовые реализации алгоритма и его описание можно найти на сайтах
* https://habrahabr.ru/post/208496/
* http://pythonhosted.org/scikit-fuzzy/auto_examples/plot_cmeans.html
* http://www.codeproject.com/Articles/91675/Computer-Vision-Applications-with-C-Fuzzy-C-means
* https://github.com/gyaikhom/fcm

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

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

2016-12-19T23:05:03Z

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

{{Assignment|ASA}}

{{algorithm
| name = Нечеткий алгоритм C средних
| serial_complexity = <math>O(C*C*K*I)</math>., где <math>I</math> - количество итераций
| input_data = <math>K*N</math>, [количество векторов * размерность]
| output_data = <math>C*K</math>, [элементы матрицы принадлежности]
| pf_height = <math>3I</math>
| pf_width = <math>C*C*K</math>
}}

Авторы : [[Участник:Protsenko|Мария Проценко]] (1.5-1.8, 2.7), [[Участник:ADovganich|Андрей Довганич]] (1.1-1.4, 1.9, 1.10)

= Свойства и структура алгоритмов =
== Общее описание алгоритма ==
Нечеткий алгоритм C-средних (fuzzy C-means) позволяет разбить имеющееся множество векторов (точек) мощностью <math>K</math> на заданное число нечетких множеств. Предназначен для кластеризации больших наборов данных. Основным достоинством алгоритма является нечеткость при определении объекта в кластер. Благодаря этому становится возможным определить объекты, которые находятся на границе, в кластеры. Из основного достоинства следует и главный недостаток - неопределенность с объектами, удаленными от центров всех кластеров. В остальном ему присущи стандартные проблемы подобного класса алгоритмов: вычислительная сложность, необходимость задания количества кластеров<ref>Нейский И.М. Классификация и сравнение методов кластеризации</ref>.

Алгоритм был разработан J.C. Dunn в 1973 г.<ref> Dunn, J. C. (1973-01-01). "A Fuzzy Relative of the ISODATA Process and Its Use in Detecting Compact Well-Separated Clusters". Journal of Cybernetics. 3 (3): 32–57. doi:10.1080/01969727308546046. ISSN 0022-0280.</ref>, усовершенствован J.C. Bezdek в 1981 г.<ref> Bezdek, James C. (1981). Pattern Recognition with Fuzzy Objective Function Algorithms. ISBN 0-306-40671-3.</ref>.

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

В общем виде алгоритм можно записать следующим образом:

# Инициализировать матрицу принадлежности;
# Вычислить центры кластеров;
# Вычислить значение решающей функции. Если значение ниже некоторого порогового или его улучшение по сравнению с предыдущей итерацией меньше определенной величины, то остановить вычисления;
# Иначе вычислить новые значения матрицы принадлежности;
# Перейти к шагу 2

== Математическое описание алгоритма ==
Рассмотрим матрицу <math> M = m_{ik} \in[0,1],\; i = 1, ..., c, \; k = 1, ..., K </math>. <math>m_{i,k}</math> - вероятность принадлежности объекта <math>k</math> к кластеру <math>i</math>; <math>c</math> - количество кластеров, <math>K</math> - количество векторов. При этом элементы матрицы удовлетворяют следующим условиям:

* сумма элементов в каждом столбце равна <math>1</math>;

* сумма всех элементов матрицы равно <math>K</math>;

Назовем <math> M </math> матрицей принадлежности.

Пусть <math>c_{i} (i = 1,2,...c)</math> - центры кластеров. Тогда рассмотрим функцию

<math>
\begin{align}
J(M, c_{1}, c_{2},...c_{c}) = \sum_{i = 1}^{c}{J_{i}} = \sum_{i = 1}^{c}\sum_{k = 1}^{K}{m_{ik}^q}d_{ik}^2 ~(1)
\end{align}
</math>

где <math> d_{ik} = \left\Vert{u_{k}-c_{i}}\right\| </math> - Евклидово расстояние между центром кластера и объектом, <math> 1 \le q \le \infty </math> - экспоненциальный весовой коэффициент, характеризующий нечеткость. Будем минимизировать значение функции <math> J </math>. Для этого вычислим центры кластеров по формуле <math> ~(2) </math>.

<math>c_{i} = {{\sum_{k = 1}^{K}{m_{ik}^q} * u_{k}} \over {\sum_{k = 1}^{K}{m_{ik}^q}}}~(2)</math>

где <math>m_{ik}</math> — коэффициент принадлежности <math>u_{k}</math> вектора к кластеру <math>c_{i}</math>

и новые значения матрицы <math> M </math> по формуле <math> ~(3) </math>

<math>m_{ik} = {1 \over \sum_{j = 1}^{c}{({{d_{ik}} \over {d_{jk}}})}^{2 \over q-1}} ~(3)</math>

<math> ~(2) </math> и <math> ~(3) </math>являются необходимым условиями достижения минимума функцией <math> J </math>. Таким образом эти два условия дают нам итерационный процесс.

Полностью алгоритм можно записать следующим образом:

# Инициализировать матрицу принадлежности <math> M </math> случайными значениями от 0 до 1;
# Вычислить центры кластеров <math>c_{i} (i = 1,2,...c)</math> используя формулу <math>~(2)</math>;
# Вычислить значение решающей функции по формуле <math>~(1)</math>. Если значение <math> J < \varepsilon,~\varepsilon > 0</math> или <math> |J_{i} - J_{i-1}| < \delta,~\delta > 0 </math>, то остановить вычисления;
# Иначе вычислить новые значения матрицы М по формуле <math>~(3)</math>;
# Перейти к шагу 2

== Вычислительное ядро алгоритма ==
Вычислительным ядром алгоритма являются формулы: <math> (1) </math>, <math> (2) </math>, <math> (3) </math>. В них производится вычисление новых центров кластеров, значения решающей функции и пересчет элементов матрицы принадлежности.

== Макроструктура алгоритма ==
Макроструктура алгоритма состоит из следующих шагов:

# Инициализация матрицы <math> M </math> случайными значениями от 0 до 1;
# Вычисление центров кластеров;
# Вычисление значения решающей функции(если оно удовлетворяет условиям останова - завершение вычислений);
# Вычисление новых элементов матрицы принадлежности;
# Переход к шагу 2;

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

Пример реализации алгоритма на языке С++. Сначала вычислим центры кластеров, потом вычислим решающую функцию, с ее помощью определим необходимость продолжать алгоритм, и при необходимости вычислим новые значения матрицы M.
<source lang="C++">

float ** m;
int *c;
int number_clusters, number_items;
m = gen_random_clusters();//заполним матрицу m случайными значениями от 0 до 1

while (true)
{
//вычисление центров кластеров
for (int i=0; i<number_clusters; i++)
{
numerator==denumerator=0;
for (int k=0; k<number_items; k++)
{
numerator+=pow(m[i, k], q)*u[k];//u[k]-вектор
denumerator+=pow(m[i, k], q);
}
c[i]= numerator / denumerator;//центры кластеров
}

j=0;//вычисление решающей функции
for (int i=0; i<number_clusters; i++)
for (int k=0; k<number_items; k++)
j+=pow(m[i, k], q)*pow(dist(c[i], x[k],2);//dist-вычисляет расстояние между заданными векторами

if ((abs(j-last_j)<delta) || (j<eps)) break;//проверка на необходимость завернешения алгоритма
last_j=j;
//обновление матрицы m
for (int i=0; i<number_clusters; i++)
for (int k=0; k<number_items; k++)
{
m[i,k]=0
for(int j=0; j<number_clusters; j++)
m[i,k]+=pow(dist(c[i], x[k])/dist(c[j], x[k]),2/(q-1));
m[i,k]=1/m[i,k];
}

}
</source>

== Последовательная сложность алгоритма ==
Каждая итерация включает в себя
* Вычисление центров кластеров <math>O(C*K)</math>
* Вычисление решающей функции <math>O(C*K)</math>
* Обновлене матрицы <math>M</math> <math>O(C*C*K)</math>
Общая сложность каждой итерации <math>O(C*C*K)</math>.

Сложность всего алгоритма будет зависеть от числа итераций, которое зависит от
* Выбора начального приближения
* Выбора условий останова

Окончательно, сложность алгоритма будет равна произведению количества итераций на их сложность

== Информационный граф ==
'''Первый ярус''' состоит из <math>C</math> параллельных операций, каждая их которых в свою очередь состоит из <math>K</math> параллельных операций, и одной, которая выполняется с использованием результата предыдущих.
Результатом работы этого яруса являются значения центров кластеров , которые будут использоваться на следующем ярусе.

'''Второй ярус''' содержит в себе <math>C*K</math> параллельных операций.
Результатом его работы является значение решающей функции <math>J</math>. Её значение определяет необходимость завершения алгоритма.

'''Третий ярус''' включает <math>C*K</math> параллельных операций, каждая из которых состоит из <math>C</math> параллельных операций, и одной, которая выполняется с использованием результата предыдущих.

[[Файл:Суперпрак.png|1200px|thumb|center|Рисунок 1 Информационный граф алгоритма. Салатовым цветом обозначены вершины графа-операции. Дугами обозначена передача информации, передаваемые данные надписаны сверху.]]

== Ресурс параллелизма алгоритма ==
На каждом шаге алгоритма необходимо вычислять сумму элементов массивов. Сложность ее вычисления на первом шаге (вычисление центров кластеров) при параллельной реализации составляет <math>O(\log_{2} C)</math>. Для каждого элемента из набора входных данных(<math> K * N </math>), но здесь возможен независимый расчет(координатный параллелизм). На втором шаге(вычисление решающей функции) сложность будет <math>O(\log_{2} {C*K*N})</math>, потому что здесь необходимо сложение всех элементов. На третьем шаге имеем сложность <math>O(\log_{2} C^2)</math>. Итого суммарная сложность итерации: <math>O(\log_{2} {C*K*N} + \log_{2} C^3)</math>. Воспользовавшись свойствами логарифма произведения получаем: <math>O(\log_{2} {K*N} + \log_{2} C^4)</math>.

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

== Входные и выходные данные алгоритма ==
Входные данные:
* <math>u_{k} ~k = 1, ..., K</math> - набор входных векторов размерности <math> N </math>;
* <math>C</math> - количество кластеров;
* <math>q</math> - экспоненциальный весовой коэффициент, характеризующий нечеткость;
* <math>\varepsilon > 0, ~\delta > 0</math> - коэффициенты, описывающие точность алгоритма.
Объем входных данных: <math> K*N </math>

Выходные данные:
* <math> M </math> - матрица принадлежности.
Объем выходных данных: <math> C*K </math>

== Свойства алгоритма ==
*Соотношение последовательной и параллельной сложности алгоритма: <math>C*C*K \over {\log_{2} {K} + \log_{2} C^4}</math>. Соответственно при распараллеливании наибольший прирост в производительности мы получим при разбиении большого набора данных на большее число кластеров;
*Вычислительная мощность: <math>{{C^2*K} \over {C*K}} = C</math>. Получается, что на чем большее количество кластеров мы разбиваем набор данных, тем менее затратным становится перемещение данных;
*Алгоритм не является устойчивым, как и другие подобные алгоритмы этого класса(например k-means). Очень многое зависит как от входных данных, так и от изначальных параметров приближения(заполнения матрицы принадлежности => исходных центров кластеров);
*Не является детерминированным. Так же очень многое зависит как от входных данных, так и от изначальных параметров приближения(заполнения матрицы принадлежности => исходных центров кластеров);
*Алгоритм не сбалансирован - доминирует операция умножения. Параллельные ветви алгоритма сбалансированы;
*Степень исхода вершины информационного графа - 2.

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

Проведём исследование масштабируемости параллельной реализации разложения Холецкого согласно [[Scalability methodology|методике]]. Исследование проводилось на суперкомпьютере "Ломоносов"<ref name="Lom">Воеводин Вл., Жуматий С., Соболев С., Антонов А., Брызгалов П., Никитенко Д., Стефанов К., Воеводин Вад. Практика суперкомпьютера «Ломоносов» // Открытые системы, 2012, N 7, С. 36-39.</ref> [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета].

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

* число процессоров [1 : 120];
* размер входных данных [1 : 15 000] векторов размерности 4.
При количестве кластеров 100.

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

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

В параллельной реализации использовалась технология OpenMP, для передачи данных данных между потоками использовалась технология MPI. Компилятор GNU(gcc) с флагом -fopenmp. Версия компилятора: gcc version 4.4.7 20120313 (Red Hat 4.4.7-4) (GCC).

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

[[file: FCM произв.jpg |thumb|center|800px|Рисунок 2 Изменение производительности.]]

[[file: FCM эф.jpg |thumb|center|800px|Рисунок 3 Изменение эффективности.]]

Оценки масштабируемости:
* По числу процессов: 0.1245.
* По размеру задачи: -0.0278.
* По двум направлениям: 0,00009.

[http://pastebin.com/LDPNY5Ua Параллельная реализация на языке С с использованием Open MP]

== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Можно найти следующие реализации алгоритма
* Для MATLAB http://www.mathworks.com/help/fuzzy/fcm.html
* В PostgreSQL http://num-meth.srcc.msu.ru/zhurnal/tom_2012/v13r207.html
Так же готовые реализации алгоритма и его описание можно найти на сайтах
* https://habrahabr.ru/post/208496/
* http://pythonhosted.org/scikit-fuzzy/auto_examples/plot_cmeans.html
* http://www.codeproject.com/Articles/91675/Computer-Vision-Applications-with-C-Fuzzy-C-means
* https://github.com/gyaikhom/fcm

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

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

2016-12-05T21:45:48Z

Protsenko: /* Замечания по тексту */

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

=== Замечания по тексту ===

* 2.4 — я не совсем понимаю, на какой именно конфигурации выполнялся анализ масштабируемости. Там написано, что используется OpenMP (для систем с общей памятью), суперкомпьютер Ломоносов, а количество процессоров доходит до 120. Я не вижу таких узлов в Ломоносове в его описании [http://parallel.ru/cluster/lomonosov.html]. Можете пояснить? [[Участник:Chalker|Chalker]] ([[Обсуждение участника:Chalker|обсуждение]]) 18:31, 5 декабря 2016 (MSK)

Запускали в тестовой очереди. В тексте допустили неточность, для передачи данных данных использовали MPI. Запустили еще раз, номер node1-130-[01-16]. 120- количество потоков.

----

* В разделе 1.5 кроме текста программы нужны словесные пояснения. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 16:38, 27 октября 2016 (MSK)
* Граф, представленный в разделе 1.7, не является информационным графом (ациклический граф, вершины - операции, дуги - информационные зависимости). [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 16:38, 27 октября 2016 (MSK)
** Приведённый граф по-прежнему является графом управления, а не информационным графом: содержит цикл, ветвление и т.д. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 11:31, 1 ноября 2016 (MSK)

* В разделе 1.9 требуется привести оценки объёма входных и выходных данных. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 16:38, 27 октября 2016 (MSK)

* Подписи к рисунку в разделе 2.4 крайне мелкие, почти неразличимые. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 15:19, 16 ноября 2016 (MSK)
* В разделе 2.4 не приведены все параметры запуска теста - какой компилятор, с какими опциями использовался, какие версии библиотек, на каких узлах проводился запуск и т.д. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 15:19, 16 ноября 2016 (MSK)
* В разделе 2.4 не приведена использованная в экспериментах реализация алгоритма. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 15:19, 16 ноября 2016 (MSK)
* Рисунки в статье не пронумерованы. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 14:04, 21 ноября 2016 (MSK)
* Из графиков в разделе 2.4 следует сделать выводы о масштабируемости реализации. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 14:04, 21 ноября 2016 (MSK)

Исправлено

Граф исправлен еще раз

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

2016-11-30T10:26:35Z

Protsenko:

{{Assignment}}

{{algorithm
| name = Нечеткий алгоритм C средних
| serial_complexity = <math>O(C*C*K*I)</math>., где <math>I</math> - количество итераций
| input_data = <math>K*N</math>, [количество векторов * размерность]
| output_data = <math>C*K</math>, [элементы матрицы принадлежности]
| pf_height = <math>3I</math>
| pf_width = <math>C*C*K</math>
}}

Авторы : [[Участник:Protsenko|Мария Проценко]] (1.5-1.8, 2.7), [[Участник:ADovganich|Андрей Довганич]] (1.1-1.4, 1.9, 1.10)

= Свойства и структура алгоритмов =
== Общее описание алгоритма ==
Нечеткий алгоритм C-средних (fuzzy C-means) позволяет разбить имеющееся множество векторов (точек) мощностью <math>K</math> на заданное число нечетких множеств. Предназначен для кластеризации больших наборов данных. Основным достоинством алгоритма является нечеткость при определении объекта в кластер. Благодаря этому становится возможным определить объекты, которые находятся на границе, в кластеры. Из основного достоинства следует и главный недостаток - неопределенность с объектами, удаленными от центров всех кластеров. В остальном ему присущи стандартные проблемы подобного класса алгоритмов: вычислительная сложность, необходимость задания количества кластеров<ref>Нейский И.М. Классификация и сравнение методов кластеризации</ref>.

Алгоритм был разработан J.C. Dunn в 1973 г.<ref> Dunn, J. C. (1973-01-01). "A Fuzzy Relative of the ISODATA Process and Its Use in Detecting Compact Well-Separated Clusters". Journal of Cybernetics. 3 (3): 32–57. doi:10.1080/01969727308546046. ISSN 0022-0280.</ref>, усовершенствован J.C. Bezdek в 1981 г.<ref> Bezdek, James C. (1981). Pattern Recognition with Fuzzy Objective Function Algorithms. ISBN 0-306-40671-3.</ref>.

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

В общем виде алгоритм можно записать следующим образом:

# Инициализировать матрицу принадлежности;
# Вычислить центры кластеров;
# Вычислить значение решающей функции. Если значение ниже некоторого порогового или его улучшение по сравнению с предыдущей итерацией меньше определенной величины, то остановить вычисления;
# Иначе вычислить новые значения матрицы принадлежности;
# Перейти к шагу 2

== Математическое описание алгоритма ==
Рассмотрим матрицу <math> M = m_{ik} \in[0,1],\; i = 1, ..., c, \; k = 1, ..., K </math>. <math>m_{i,k}</math> - вероятность принадлежности объекта <math>k</math> к кластеру <math>i</math>; <math>c</math> - количество кластеров, <math>K</math> - количество векторов. При этом элементы матрицы удовлетворяют следующим условиям:

* сумма элементов в каждом столбце равна <math>1</math>;

* сумма всех элементов матрицы равно <math>K</math>;

Назовем <math> M </math> матрицей принадлежности.

Пусть <math>c_{i} (i = 1,2,...c)</math> - центры кластеров. Тогда рассмотрим функцию

<math>
\begin{align}
J(M, c_{1}, c_{2},...c_{c}) = \sum_{i = 1}^{c}{J_{i}} = \sum_{i = 1}^{c}\sum_{k = 1}^{K}{m_{ik}^q}d_{ik}^2 ~(1)
\end{align}
</math>

где <math> d_{ik} = \left\Vert{u_{k}-c_{i}}\right\| </math> - Евклидово расстояние между центром кластера и объектом, <math> 1 \le q \le \infty </math> - экспоненциальный весовой коэффициент, характеризующий нечеткость. Будем минимизировать значение функции <math> J </math>. Для этого вычислим центры кластеров по формуле <math> ~(2) </math>.

<math>c_{i} = {{\sum_{k = 1}^{K}{m_{ik}^q} * u_{k}} \over {\sum_{k = 1}^{K}{m_{ik}^q}}}~(2)</math>

где <math>m_{ik}</math> — коэффициент принадлежности <math>u_{k}</math> вектора к кластеру <math>c_{i}</math>

и новые значения матрицы <math> M </math> по формуле <math> ~(3) </math>

<math>m_{ik} = {1 \over \sum_{j = 1}^{c}{({{d_{ik}} \over {d_{jk}}})}^{2 \over q-1}} ~(3)</math>

<math> ~(2) </math> и <math> ~(3) </math>являются необходимым условиями достижения минимума функцией <math> J </math>. Таким образом эти два условия дают нам итерационный процесс.

Полностью алгоритм можно записать следующим образом:

# Инициализировать матрицу принадлежности <math> M </math> случайными значениями от 0 до 1;
# Вычислить центры кластеров <math>c_{i} (i = 1,2,...c)</math> используя формулу <math>~(2)</math>;
# Вычислить значение решающей функции по формуле <math>~(1)</math>. Если значение <math> J < \varepsilon,~\varepsilon > 0</math> или <math> |J_{i} - J_{i-1}| < \delta,~\delta > 0 </math>, то остановить вычисления;
# Иначе вычислить новые значения матрицы М по формуле <math>~(3)</math>;
# Перейти к шагу 2

== Вычислительное ядро алгоритма ==
Вычислительным ядром алгоритма являются формулы: <math> (1) </math>, <math> (2) </math>, <math> (3) </math>. В них производится вычисление новых центров кластеров, значения решающей функции и пересчет элементов матрицы принадлежности.

== Макроструктура алгоритма ==
Макроструктура алгоритма состоит из следующих шагов:

# Инициализация матрицы <math> M </math> случайными значениями от 0 до 1;
# Вычисление центров кластеров;
# Вычисление значения решающей функции(если оно удовлетворяет условиям останова - завершение вычислений);
# Вычисление новых элементов матрицы принадлежности;
# Переход к шагу 2;

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

Пример реализации алгоритма на языке С++. Сначала вычислим центры кластеров, потом вычислим решающую функцию, с ее помощью определим необходимость продолжать алгоритм, и при необходимости вычислим новые значения матрицы M.
<source lang="C++">

float ** m;
int *c;
int number_clusters, number_items;
m = gen_random_clusters();//заполним матрицу m случайными значениями от 0 до 1

while (true)
{
//вычисление центров кластеров
for (int i=0; i<number_clusters; i++)
{
numerator==denumerator=0;
for (int k=0; k<number_items; k++)
{
numerator+=pow(m[i, k], q)*u[k];//u[k]-вектор
denumerator+=pow(m[i, k], q);
}
c[i]= numerator / denumerator;//центры кластеров
}

j=0;//вычисление решающей функции
for (int i=0; i<number_clusters; i++)
for (int k=0; k<number_items; k++)
j+=pow(m[i, k], q)*pow(dist(c[i], x[k],2);//dist-вычисляет расстояние между заданными векторами

if ((abs(j-last_j)<delta) || (j<eps)) break;//проверка на необходимость завернешения алгоритма
last_j=j;
//обновление матрицы m
for (int i=0; i<number_clusters; i++)
for (int k=0; k<number_items; k++)
{
m[i,k]=0
for(int j=0; j<number_clusters; j++)
m[i,k]+=pow(dist(c[i], x[k])/dist(c[j], x[k]),2/(q-1));
m[i,k]=1/m[i,k];
}

}
</source>

== Последовательная сложность алгоритма ==
Каждая итерация включает в себя
* Вычисление центров кластеров <math>O(C*K)</math>
* Вычисление решающей функции <math>O(C*K)</math>
* Обновлене матрицы <math>M</math> <math>O(C*C*K)</math>
Общая сложность каждой итерации <math>O(C*C*K)</math>.

Сложность всего алгоритма будет зависеть от числа итераций, которое зависит от
* Выбора начального приближения
* Выбора условий останова

Окончательно, сложность алгоритма будет равна произведению количества итераций на их сложность

== Информационный граф ==
'''Первый ярус''' состоит из <math>C</math> параллельных операций, каждая их которых в свою очередь состоит из <math>K</math> параллельных операций, и одной, которая выполняется с использованием результата предыдущих.
Результатом работы этого яруса являются значения центров кластеров , которые будут использоваться на следующем ярусе.

'''Второй ярус''' содержит в себе <math>C*K</math> параллельных операций.
Результатом его работы является значение решающей функции <math>J</math>. Её значение определяет необходимость завершения алгоритма.

'''Третий ярус''' включает <math>C*K</math> параллельных операций, каждая из которых состоит из <math>C</math> параллельных операций, и одной, которая выполняется с использованием результата предыдущих.

[[Файл:Суперпрак.png|1200px|thumb|center|Рисунок 1 Информационный граф алгоритма. Салатовым цветом обозначены вершины графа-операции. Дугами обозначена передача информации, передаваемые данные надписаны сверху.]]

== Ресурс параллелизма алгоритма ==
На каждом шаге алгоритма необходимо вычислять сумму элементов массивов. Сложность ее вычисления на первом шаге (вычисление центров кластеров) при параллельной реализации составляет <math>O(\log_{2} C)</math>. Для каждого элемента из набора входных данных(<math> K </math>), но здесь возможен независимый расчет(координатный параллелизм). На втором шаге(вычисление решающей функции) сложность будет <math>O(\log_{2} {C*K})</math>, потому что здесь необходимо сложение всех элементов. На третьем шаге имеем сложность <math>O(\log_{2} C^2)</math>. Итого суммарная сложность итерации: <math>O(\log_{2} {C*K} + \log_{2} C^3)</math>. Воспользовавшись свойствами логарифма произведения получаем: <math>O(\log_{2} {K} + \log_{2} C^4)</math>.

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

== Входные и выходные данные алгоритма ==
Входные данные:
* <math>u_{k} ~k = 1, ..., K</math> - набор входных векторов размерности <math> N </math>;
* <math>C</math> - количество кластеров;
* <math>q</math> - экспоненциальный весовой коэффициент, характеризующий нечеткость;
* <math>\varepsilon > 0, ~\delta > 0</math> - коэффициенты, описывающие точность алгоритма.
Объем входных данных: <math> K*N </math>

Выходные данные:
* <math> M </math> - матрица принадлежности.
Объем выходных данных: <math> C*K </math>

== Свойства алгоритма ==
*Соотношение последовательной и параллельной сложности алгоритма: <math>C*C*K \over {\log_{2} {K} + \log_{2} C^4}</math>. Соответственно при распараллеливании наибольший прирост в производительности мы получим при разбиении большого набора данных на большее число кластеров;
*Вычислительная мощность: <math>{{C^2*K} \over {C*K}} = C</math>. Получается, что на чем большее количество кластеров мы разбиваем набор данных, тем менее затратным становится перемещение данных;
*Алгоритм не является устойчивым, как и другие подобные алгоритмы этого класса(например k-means). Очень многое зависит как от входных данных, так и от изначальных параметров приближения(заполнения матрицы принадлежности => исходных центров кластеров);
*Не является детерминированным. Так же очень многое зависит как от входных данных, так и от изначальных параметров приближения(заполнения матрицы принадлежности => исходных центров кластеров);
*Алгоритм не сбалансирован - доминирует операция умножения. Параллельные ветви алгоритма сбалансированы;
*Степень исхода вершины информационного графа - 2.

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

Проведём исследование масштабируемости параллельной реализации разложения Холецкого согласно [[Scalability methodology|методике]]. Исследование проводилось на суперкомпьютере "Ломоносов"<ref name="Lom">Воеводин Вл., Жуматий С., Соболев С., Антонов А., Брызгалов П., Никитенко Д., Стефанов К., Воеводин Вад. Практика суперкомпьютера «Ломоносов» // Открытые системы, 2012, N 7, С. 36-39.</ref> [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета].

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

* число процессоров [1 : 120];
* размер входных данных [1 : 15 000] векторов размерности 4.
При количестве кластеров 100.

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

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

В параллельной реализации использовалась технология OpenMP. Компилятор GNU(gcc) с флагом -fopenmp. Версия компилятора: gcc version 4.4.7 20120313 (Red Hat 4.4.7-4) (GCC).

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

[[file: FCM произв.jpg |thumb|center|800px|Рисунок 2 Изменение производительности.]]

[[file: FCM эф.jpg |thumb|center|800px|Рисунок 3 Изменение эффективности.]]

Оценки масштабируемости:
* По числу процессов: 0.1245.
* По размеру задачи: -0.0278.
* По двум направлениям: 0,00009.

[http://pastebin.com/LDPNY5Ua Параллельная реализация на языке С с использованием Open MP]

== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Можно найти следующие реализации алгоритма
* Для MATLAB http://www.mathworks.com/help/fuzzy/fcm.html
* В PostgreSQL http://num-meth.srcc.msu.ru/zhurnal/tom_2012/v13r207.html
Так же готовые реализации алгоритма и его описание можно найти на сайтах
* https://habrahabr.ru/post/208496/
* http://pythonhosted.org/scikit-fuzzy/auto_examples/plot_cmeans.html
* http://www.codeproject.com/Articles/91675/Computer-Vision-Applications-with-C-Fuzzy-C-means
* https://github.com/gyaikhom/fcm

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

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

2016-11-29T19:24:04Z

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

{{algorithm
| name = Нечеткий алгоритм C средних
| serial_complexity = <math>O(C*C*K*I)</math>., где <math>I</math> - количество итераций
| input_data = <math>K*N</math>, [количество векторов * размерность]
| output_data = <math>C*K</math>, [элементы матрицы принадлежности]
| pf_height = <math>3I</math>
| pf_width = <math>C*C*K</math>
}}

Авторы : [[Участник:Protsenko|Мария Проценко]] (1.5-1.8, 2.7), [[Участник:ADovganich|Андрей Довганич]] (1.1-1.4, 1.9, 1.10)

= Свойства и структура алгоритмов =
== Общее описание алгоритма ==
Нечеткий алгоритм C-средних (fuzzy C-means) позволяет разбить имеющееся множество векторов (точек) мощностью <math>K</math> на заданное число нечетких множеств. Предназначен для кластеризации больших наборов данных. Основным достоинством алгоритма является нечеткость при определении объекта в кластер. Благодаря этому становится возможным определить объекты, которые находятся на границе, в кластеры. Из основного достоинства следует и главный недостаток - неопределенность с объектами, удаленными от центров всех кластеров. В остальном ему присущи стандартные проблемы подобного класса алгоритмов: вычислительная сложность, необходимость задания количества кластеров<ref>Нейский И.М. Классификация и сравнение методов кластеризации</ref>.

Алгоритм был разработан J.C. Dunn в 1973 г.<ref> Dunn, J. C. (1973-01-01). "A Fuzzy Relative of the ISODATA Process and Its Use in Detecting Compact Well-Separated Clusters". Journal of Cybernetics. 3 (3): 32–57. doi:10.1080/01969727308546046. ISSN 0022-0280.</ref>, усовершенствован J.C. Bezdek в 1981 г.<ref> Bezdek, James C. (1981). Pattern Recognition with Fuzzy Objective Function Algorithms. ISBN 0-306-40671-3.</ref>.

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

В общем виде алгоритм можно записать следующим образом:

# Инициализировать матрицу принадлежности;
# Вычислить центры кластеров;
# Вычислить значение решающей функции. Если значение ниже некоторого порогового или его улучшение по сравнению с предыдущей итерацией меньше определенной величины, то остановить вычисления;
# Иначе вычислить новые значения матрицы принадлежности;
# Перейти к шагу 2

== Математическое описание алгоритма ==
Рассмотрим матрицу <math> M = m_{ik} \in[0,1],\; i = 1, ..., c, \; k = 1, ..., K </math>. <math>m_{i,k}</math> - вероятность принадлежности объекта <math>k</math> к кластеру <math>i</math>; <math>c</math> - количество кластеров, <math>K</math> - количество векторов. При этом элементы матрицы удовлетворяют следующим условиям:

* сумма элементов в каждом столбце равна <math>1</math>;

* сумма всех элементов матрицы равно <math>K</math>;

Назовем <math> M </math> матрицей принадлежности.

Пусть <math>c_{i} (i = 1,2,...c)</math> - центры кластеров. Тогда рассмотрим функцию

<math>
\begin{align}
J(M, c_{1}, c_{2},...c_{c}) = \sum_{i = 1}^{c}{J_{i}} = \sum_{i = 1}^{c}\sum_{k = 1}^{K}{m_{ik}^q}d_{ik}^2 ~(1)
\end{align}
</math>

где <math> d_{ik} = \left\Vert{u_{k}-c_{i}}\right\| </math> - Евклидово расстояние между центром кластера и объектом, <math> 1 \le q \le \infty </math> - экспоненциальный весовой коэффициент, характеризующий нечеткость. Будем минимизировать значение функции <math> J </math>. Для этого вычислим центры кластеров по формуле <math> ~(2) </math>.

<math>c_{i} = {{\sum_{k = 1}^{K}{m_{ik}^q} * u_{k}} \over {\sum_{k = 1}^{K}{m_{ik}^q}}}~(2)</math>

где <math>m_{ik}</math> — коэффициент принадлежности <math>u_{k}</math> вектора к кластеру <math>c_{i}</math>

и новые значения матрицы <math> M </math> по формуле <math> ~(3) </math>

<math>m_{ik} = {1 \over \sum_{j = 1}^{c}{({{d_{ik}} \over {d_{jk}}})}^{2 \over q-1}} ~(3)</math>

<math> ~(2) </math> и <math> ~(3) </math>являются необходимым условиями достижения минимума функцией <math> J </math>. Таким образом эти два условия дают нам итерационный процесс.

Полностью алгоритм можно записать следующим образом:

# Инициализировать матрицу принадлежности <math> M </math> случайными значениями от 0 до 1;
# Вычислить центры кластеров <math>c_{i} (i = 1,2,...c)</math> используя формулу <math>~(2)</math>;
# Вычислить значение решающей функции по формуле <math>~(1)</math>. Если значение <math> J < \varepsilon,~\varepsilon > 0</math> или <math> |J_{i} - J_{i-1}| < \delta,~\delta > 0 </math>, то остановить вычисления;
# Иначе вычислить новые значения матрицы М по формуле <math>~(3)</math>;
# Перейти к шагу 2

== Вычислительное ядро алгоритма ==
Вычислительным ядром алгоритма являются формулы: <math> (1) </math>, <math> (2) </math>, <math> (3) </math>. В них производится вычисление новых центров кластеров, значения решающей функции и пересчет элементов матрицы принадлежности.

== Макроструктура алгоритма ==
Макроструктура алгоритма состоит из следующих шагов:

# Инициализация матрицы <math> M </math> случайными значениями от 0 до 1;
# Вычисление центров кластеров;
# Вычисление значения решающей функции(если оно удовлетворяет условиям останова - завершение вычислений);
# Вычисление новых элементов матрицы принадлежности;
# Переход к шагу 2;

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

Пример реализации алгоритма на языке С++. Сначала вычислим центры кластеров, потом вычислим решающую функцию, с ее помощью определим необходимость продолжать алгоритм, и при необходимости вычислим новые значения матрицы M.
<source lang="C++">

float ** m;
int *c;
int number_clusters, number_items;
m = gen_random_clusters();//заполним матрицу m случайными значениями от 0 до 1

while (true)
{
//вычисление центров кластеров
for (int i=0; i<number_clusters; i++)
{
numerator==denumerator=0;
for (int k=0; k<number_items; k++)
{
numerator+=pow(m[i, k], q)*u[k];//u[k]-вектор
denumerator+=pow(m[i, k], q);
}
c[i]= numerator / denumerator;//центры кластеров
}

j=0;//вычисление решающей функции
for (int i=0; i<number_clusters; i++)
for (int k=0; k<number_items; k++)
j+=pow(m[i, k], q)*pow(dist(c[i], x[k],2);//dist-вычисляет расстояние между заданными векторами

if ((abs(j-last_j)<delta) || (j<eps)) break;//проверка на необходимость завернешения алгоритма
last_j=j;
//обновление матрицы m
for (int i=0; i<number_clusters; i++)
for (int k=0; k<number_items; k++)
{
m[i,k]=0
for(int j=0; j<number_clusters; j++)
m[i,k]+=pow(dist(c[i], x[k])/dist(c[j], x[k]),2/(q-1));
m[i,k]=1/m[i,k];
}

}
</source>

== Последовательная сложность алгоритма ==
Каждая итерация включает в себя
* Вычисление центров кластеров <math>O(C*K)</math>
* Вычисление решающей функции <math>O(C*K)</math>
* Обновлене матрицы <math>M</math> <math>O(C*C*K)</math>
Общая сложность каждой итерации <math>O(C*C*K)</math>.

Сложность всего алгоритма будет зависеть от числа итераций, которое зависит от
* Выбора начального приближения
* Выбора условий останова

Окончательно, сложность алгоритма будет равна произведению количества итераций на их сложность

== Информационный граф ==
'''Первый ярус''' состоит из <math>C</math> параллельных операций, каждая их которых в свою очередь состоит из <math>K</math> параллельных операций, и одной, которая выполняется с использованием результата предыдущих.
Результатом работы этого яруса являются значения центров кластеров , которые будут использоваться на следующем ярусе.

'''Второй ярус''' содержит в себе <math>C*K</math> параллельных операций.
Результатом его работы является значение решающей функции <math>J</math>. Её значение определяет необходимость завершения алгоритма.

'''Третий ярус''' включает <math>C*K</math> параллельных операций, каждая из которых состоит из <math>C</math> параллельных операций, и одной, которая выполняется с использованием результата предыдущих.

[[Файл:Суперпрак.png|1200px|thumb|center|Рисунок 1 Информационный граф алгоритма. Салатовым цветом обозначены вершины графа-операции. Дугами обозначена передача информации, передаваемые данные надписаны сверху.]]

== Ресурс параллелизма алгоритма ==
На каждом шаге алгоритма необходимо вычислять сумму элементов массивов. Сложность ее вычисления на первом шаге (вычисление центров кластеров) при параллельной реализации составляет <math>O(\log_{2} C)</math>. Для каждого элемента из набора входных данных(<math> K </math>), но здесь возможен независимый расчет(координатный параллелизм). На втором шаге(вычисление решающей функции) сложность будет <math>O(\log_{2} {C*K})</math>, потому что здесь необходимо сложение всех элементов. На третьем шаге имеем сложность <math>O(\log_{2} C^2)</math>. Итого суммарная сложность итерации: <math>O(\log_{2} {C*K} + \log_{2} C^3)</math>. Воспользовавшись свойствами логарифма произведения получаем: <math>O(\log_{2} {K} + \log_{2} C^4)</math>.

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

== Входные и выходные данные алгоритма ==
Входные данные:
* <math>u_{k} ~k = 1, ..., K</math> - набор входных векторов размерности <math> N </math>;
* <math>C</math> - количество кластеров;
* <math>q</math> - экспоненциальный весовой коэффициент, характеризующий нечеткость;
* <math>\varepsilon > 0, ~\delta > 0</math> - коэффициенты, описывающие точность алгоритма.
Объем входных данных: <math> K*N </math>

Выходные данные:
* <math> M </math> - матрица принадлежности.
Объем выходных данных: <math> C*K </math>

== Свойства алгоритма ==
*Соотношение последовательной и параллельной сложности алгоритма: <math>C*C*K \over {\log_{2} {K} + \log_{2} C^4}</math>. Соответственно при распараллеливании наибольший прирост в производительности мы получим при разбиении большого набора данных на большее число кластеров;
*Вычислительная мощность: <math>{{C^2*K} \over {C*K}} = C</math>. Получается, что на чем большее количество кластеров мы разбиваем набор данных, тем менее затратным становится перемещение данных;
*Алгоритм не является устойчивым, как и другие подобные алгоритмы этого класса(например k-means). Очень многое зависит как от входных данных, так и от изначальных параметров приближения(заполнения матрицы принадлежности => исходных центров кластеров);
*Не является детерминированным. Так же очень многое зависит как от входных данных, так и от изначальных параметров приближения(заполнения матрицы принадлежности => исходных центров кластеров);
*Алгоритм не сбалансирован - доминирует операция умножения. Параллельные ветви алгоритма сбалансированы;
*Степень исхода вершины информационного графа - 2.

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

Проведём исследование масштабируемости параллельной реализации разложения Холецкого согласно [[Scalability methodology|методике]]. Исследование проводилось на суперкомпьютере "Ломоносов"<ref name="Lom">Воеводин Вл., Жуматий С., Соболев С., Антонов А., Брызгалов П., Никитенко Д., Стефанов К., Воеводин Вад. Практика суперкомпьютера «Ломоносов» // Открытые системы, 2012, N 7, С. 36-39.</ref> [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета].

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

* число процессоров [1 : 120];
* размер входных данных [1 : 15 000] векторов размерности 4.
При количестве кластеров 100.

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

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

В параллельной реализации использовалась технология OpenMP. Компилятор GNU(gcc) с флагом -fopenmp. Версия компилятора: gcc version 4.4.7 20120313 (Red Hat 4.4.7-4) (GCC).

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

[[file: FCM произв.jpg |thumb|center|800px|Рисунок 2 Изменение производительности.]]

[[file: FCM эф.jpg |thumb|center|800px|Рисунок 3 Изменение эффективности.]]

Оценки масштабируемости:
* По числу процессов: 0.1245.
* По размеру задачи: -0.0278.
* По двум направлениям: 0,00009.

[http://pastebin.com/LDPNY5Ua Параллельная реализация на языке С с использованием Open MP]

== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Можно найти следующие реализации алгоритма
* Для MATLAB http://www.mathworks.com/help/fuzzy/fcm.html
* В PostgreSQL http://num-meth.srcc.msu.ru/zhurnal/tom_2012/v13r207.html
Так же готовые реализации алгоритма и его описание можно найти на сайтах
* https://habrahabr.ru/post/208496/
* http://pythonhosted.org/scikit-fuzzy/auto_examples/plot_cmeans.html
* http://www.codeproject.com/Articles/91675/Computer-Vision-Applications-with-C-Fuzzy-C-means
* https://github.com/gyaikhom/fcm

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

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

2016-11-29T19:23:46Z

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

{{algorithm
| name = Нечеткий алгоритм C средних
| serial_complexity = <math>O(C*C*K*I)</math>., где <math>I</math> - количество итераций
| input_data = <math>K*N</math>, [количество векторов * размерность]
| output_data = <math>C*K</math>, [элементы матрицы принадлежности]
| pf_height = <math>3I</math>
| pf_width = <math>C*C*K</math>
}}

Авторы : [[Участник:Protsenko|Мария Проценко]] (1.5-1.8, 2.7), [[Участник:ADovganich|Андрей Довганич]] (1.1-1.4, 1.9, 1.10)

= Свойства и структура алгоритмов =
== Общее описание алгоритма ==
Нечеткий алгоритм C-средних (fuzzy C-means) позволяет разбить имеющееся множество векторов (точек) мощностью <math>K</math> на заданное число нечетких множеств. Предназначен для кластеризации больших наборов данных. Основным достоинством алгоритма является нечеткость при определении объекта в кластер. Благодаря этому становится возможным определить объекты, которые находятся на границе, в кластеры. Из основного достоинства следует и главный недостаток - неопределенность с объектами, удаленными от центров всех кластеров. В остальном ему присущи стандартные проблемы подобного класса алгоритмов: вычислительная сложность, необходимость задания количества кластеров<ref>Нейский И.М. Классификация и сравнение методов кластеризации</ref>.

Алгоритм был разработан J.C. Dunn в 1973 г.<ref> Dunn, J. C. (1973-01-01). "A Fuzzy Relative of the ISODATA Process and Its Use in Detecting Compact Well-Separated Clusters". Journal of Cybernetics. 3 (3): 32–57. doi:10.1080/01969727308546046. ISSN 0022-0280.</ref>, усовершенствован J.C. Bezdek в 1981 г.<ref> Bezdek, James C. (1981). Pattern Recognition with Fuzzy Objective Function Algorithms. ISBN 0-306-40671-3.</ref>.

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

В общем виде алгоритм можно записать следующим образом:

# Инициализировать матрицу принадлежности;
# Вычислить центры кластеров;
# Вычислить значение решающей функции. Если значение ниже некоторого порогового или его улучшение по сравнению с предыдущей итерацией меньше определенной величины, то остановить вычисления;
# Иначе вычислить новые значения матрицы принадлежности;
# Перейти к шагу 2

== Математическое описание алгоритма ==
Рассмотрим матрицу <math> M = m_{ik} \in[0,1],\; i = 1, ..., c, \; k = 1, ..., K </math>. <math>m_{i,k}</math> - вероятность принадлежности объекта <math>k</math> к кластеру <math>i</math>; <math>c</math> - количество кластеров, <math>K</math> - количество векторов. При этом элементы матрицы удовлетворяют следующим условиям:

* сумма элементов в каждом столбце равна <math>1</math>;

* сумма всех элементов матрицы равно <math>K</math>;

Назовем <math> M </math> матрицей принадлежности.

Пусть <math>c_{i} (i = 1,2,...c)</math> - центры кластеров. Тогда рассмотрим функцию

<math>
\begin{align}
J(M, c_{1}, c_{2},...c_{c}) = \sum_{i = 1}^{c}{J_{i}} = \sum_{i = 1}^{c}\sum_{k = 1}^{K}{m_{ik}^q}d_{ik}^2 ~(1)
\end{align}
</math>

где <math> d_{ik} = \left\Vert{u_{k}-c_{i}}\right\| </math> - Евклидово расстояние между центром кластера и объектом, <math> 1 \le q \le \infty </math> - экспоненциальный весовой коэффициент, характеризующий нечеткость. Будем минимизировать значение функции <math> J </math>. Для этого вычислим центры кластеров по формуле <math> ~(2) </math>.

<math>c_{i} = {{\sum_{k = 1}^{K}{m_{ik}^q} * u_{k}} \over {\sum_{k = 1}^{K}{m_{ik}^q}}}~(2)</math>

где <math>m_{ik}</math> — коэффициент принадлежности <math>u_{k}</math> вектора к кластеру <math>c_{i}</math>

и новые значения матрицы <math> M </math> по формуле <math> ~(3) </math>

<math>m_{ik} = {1 \over \sum_{j = 1}^{c}{({{d_{ik}} \over {d_{jk}}})}^{2 \over q-1}} ~(3)</math>

<math> ~(2) </math> и <math> ~(3) </math>являются необходимым условиями достижения минимума функцией <math> J </math>. Таким образом эти два условия дают нам итерационный процесс.

Полностью алгоритм можно записать следующим образом:

# Инициализировать матрицу принадлежности <math> M </math> случайными значениями от 0 до 1;
# Вычислить центры кластеров <math>c_{i} (i = 1,2,...c)</math> используя формулу <math>~(2)</math>;
# Вычислить значение решающей функции по формуле <math>~(1)</math>. Если значение <math> J < \varepsilon,~\varepsilon > 0</math> или <math> |J_{i} - J_{i-1}| < \delta,~\delta > 0 </math>, то остановить вычисления;
# Иначе вычислить новые значения матрицы М по формуле <math>~(3)</math>;
# Перейти к шагу 2

== Вычислительное ядро алгоритма ==
Вычислительным ядром алгоритма являются формулы: <math> (1) </math>, <math> (2) </math>, <math> (3) </math>. В них производится вычисление новых центров кластеров, значения решающей функции и пересчет элементов матрицы принадлежности.

== Макроструктура алгоритма ==
Макроструктура алгоритма состоит из следующих шагов:

# Инициализация матрицы <math> M </math> случайными значениями от 0 до 1;
# Вычисление центров кластеров;
# Вычисление значения решающей функции(если оно удовлетворяет условиям останова - завершение вычислений);
# Вычисление новых элементов матрицы принадлежности;
# Переход к шагу 2;

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

Пример реализации алгоритма на языке С++. Сначала вычислим центры кластеров, потом вычислим решающую функцию, с ее помощью определим необходимость продолжать алгоритм, и при необходимости вычислим новые значения матрицы M.
<source lang="C++">

float ** m;
int *c;
int number_clusters, number_items;
m = gen_random_clusters();//заполним матрицу m случайными значениями от 0 до 1

while (true)
{
//вычисление центров кластеров
for (int i=0; i<number_clusters; i++)
{
numerator==denumerator=0;
for (int k=0; k<number_items; k++)
{
numerator+=pow(m[i, k], q)*u[k];//u[k]-вектор
denumerator+=pow(m[i, k], q);
}
c[i]= numerator / denumerator;//центры кластеров
}

j=0;//вычисление решающей функции
for (int i=0; i<number_clusters; i++)
for (int k=0; k<number_items; k++)
j+=pow(m[i, k], q)*pow(dist(c[i], x[k],2);//dist-вычисляет расстояние между заданными векторами

if ((abs(j-last_j)<delta) || (j<eps)) break;//проверка на необходимость завернешения алгоритма
last_j=j;
//обновление матрицы m
for (int i=0; i<number_clusters; i++)
for (int k=0; k<number_items; k++)
{
m[i,k]=0
for(int j=0; j<number_clusters; j++)
m[i,k]+=pow(dist(c[i], x[k])/dist(c[j], x[k]),2/(q-1));
m[i,k]=1/m[i,k];
}

}
</source>

== Последовательная сложность алгоритма ==
Каждая итерация включает в себя
* Вычисление центров кластеров <math>O(C*K)</math>
* Вычисление решающей функции <math>O(C*K)</math>
* Обновлене матрицы <math>M</math> <math>O(C*C*K)</math>
Общая сложность каждой итерации <math>O(C*C*K)</math>.

Сложность всего алгоритма будет зависеть от числа итераций, которое зависит от
* Выбора начального приближения
* Выбора условий останова

Окончательно, сложность алгоритма будет равна произведению количества итераций на их сложность

== Информационный граф ==
'''Первый ярус''' состоит из <math>C</math> параллельных операций, каждая их которых в свою очередь состоит из <math>K</math> параллельных операций, и одной, которая выполняется с использованием результата предыдущих.
Результатом работы этого яруса являются значения центров кластеров , которые будут использоваться на следующем ярусе.

'''Второй ярус''' содержит в себе <math>C*K</math> параллельных операций.
Результатом его работы является значение решающей функции <math>J</math>. Её значение определяет необходимость завершения алгоритма.

'''Третий ярус''' включает <math>C*K</math> параллельных операций, каждая из которых состоит из <math>C</math> параллельных операций, и одной, которая выполняется с использованием результата предыдущих.

[[Файл:Суперпрак.png|1200px|thumb|center|Рисунок 1 Информационный граф алгоритма. Салатовым цветом обозначены вершины графа-операции. Дугами обозначена передача информации, передаваемые данные надписаны сверху.]]

== Ресурс параллелизма алгоритма ==
На каждом шаге алгоритма необходимо вычислять сумму элементов массивов. Сложность ее вычисления на первом шаге (вычисление центров кластеров) при параллельной реализации составляет <math>O(\log_{2} C)</math>. Для каждого элемента из набора входных данных(<math> K </math>), но здесь возможен независимый расчет(координатный параллелизм). На втором шаге(вычисление решающей функции) сложность будет <math>O(\log_{2} {C*K})</math>, потому что здесь необходимо сложение всех элементов. На третьем шаге имеем сложность <math>O(\log_{2} C^2)</math>. Итого суммарная сложность итерации: <math>O(\log_{2} {C*K} + \log_{2} C^3)</math>. Воспользовавшись свойствами логарифма произведения получаем: <math>O(\log_{2} {K} + \log_{2} C^4)</math>.

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

== Входные и выходные данные алгоритма ==
Входные данные:
* <math>u_{k} ~k = 1, ..., K</math> - набор входных векторов размерности <math> N </math>;
* <math>C</math> - количество кластеров;
* <math>q</math> - экспоненциальный весовой коэффициент, характеризующий нечеткость;
* <math>\varepsilon > 0, ~\delta > 0</math> - коэффициенты, описывающие точность алгоритма.
Объем входных данных: <math> K*N </math>

Выходные данные:
* <math> M </math> - матрица принадлежности.
Объем выходных данных: <math> C*K </math>

== Свойства алгоритма ==
*Соотношение последовательной и параллельной сложности алгоритма: <math>C*C*K \over {\log_{2} {K} + \log_{2} C^4}</math>. Соответственно при распараллеливании наибольший прирост в производительности мы получим при разбиении большого набора данных на большее число кластеров;
*Вычислительная мощность: <math>{{C^2*K} \over {C*K}} = C</math>. Получается, что на чем большее количество кластеров мы разбиваем набор данных, тем менее затратным становится перемещение данных;
*Алгоритм не является устойчивым, как и другие подобные алгоритмы этого класса(например k-means). Очень многое зависит как от входных данных, так и от изначальных параметров приближения(заполнения матрицы принадлежности => исходных центров кластеров);
*Не является детерминированным. Так же очень многое зависит как от входных данных, так и от изначальных параметров приближения(заполнения матрицы принадлежности => исходных центров кластеров);
*Алгоритм не сбалансирован - доминирует операция умножения. Параллельные ветви алгоритма сбалансированы;
*Степень исхода вершины информационного графа - 2.

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

Проведём исследование масштабируемости параллельной реализации разложения Холецкого согласно [[Scalability methodology|методике]]. Исследование проводилось на суперкомпьютере "Ломоносов"<ref name="Lom">Воеводин Вл., Жуматий С., Соболев С., Антонов А., Брызгалов П., Никитенко Д., Стефанов К., Воеводин Вад. Практика суперкомпьютера «Ломоносов» // Открытые системы, 2012, N 7, С. 36-39.</ref> [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета].

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

* число процессоров [1 : 120];
* размер входных данных [1 : 15 000] векторов размерности 4.
При количестве кластеров 100.

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

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

В параллельной реализации использовалась технология OpenMP. Компилятор GNU(gcc) с флагом -fopenmp. Версия компилятора: gcc version 4.4.7 20120313 (Red Hat 4.4.7-4) (GCC).

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

[[file: FCM произв.jpg |thumb|center|800px|Изменение производительности.]]

[[file: FCM эф.jpg |thumb|center|800px|Изменение эффективности.]]

Оценки масштабируемости:
* По числу процессов: 0.1245.
* По размеру задачи: -0.0278.
* По двум направлениям: 0,00009.

[http://pastebin.com/LDPNY5Ua Параллельная реализация на языке С с использованием Open MP]

== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Можно найти следующие реализации алгоритма
* Для MATLAB http://www.mathworks.com/help/fuzzy/fcm.html
* В PostgreSQL http://num-meth.srcc.msu.ru/zhurnal/tom_2012/v13r207.html
Так же готовые реализации алгоритма и его описание можно найти на сайтах
* https://habrahabr.ru/post/208496/
* http://pythonhosted.org/scikit-fuzzy/auto_examples/plot_cmeans.html
* http://www.codeproject.com/Articles/91675/Computer-Vision-Applications-with-C-Fuzzy-C-means
* https://github.com/gyaikhom/fcm

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

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

2016-11-28T21:43:20Z

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

{{algorithm
| name = Нечеткий алгоритм C средних
| serial_complexity = <math>O(C*C*K*I)</math>., где <math>I</math> - количество итераций
| input_data = <math>K*N</math>, [количество векторов * размерность]
| output_data = <math>C*K</math>, [элементы матрицы принадлежности]
| pf_height = <math>3I</math>
| pf_width = <math>C*C*K</math>
}}

Авторы : [[Участник:Protsenko|Мария Проценко]] (1.5-1.8, 2.7), [[Участник:ADovganich|Андрей Довганич]] (1.1-1.4, 1.9, 1.10)

= Свойства и структура алгоритмов =
== Общее описание алгоритма ==
Нечеткий алгоритм C-средних (fuzzy C-means) позволяет разбить имеющееся множество векторов (точек) мощностью <math>K</math> на заданное число нечетких множеств. Предназначен для кластеризации больших наборов данных. Основным достоинством алгоритма является нечеткость при определении объекта в кластер. Благодаря этому становится возможным определить объекты, которые находятся на границе, в кластеры. Из основного достоинства следует и главный недостаток - неопределенность с объектами, удаленными от центров всех кластеров. В остальном ему присущи стандартные проблемы подобного класса алгоритмов: вычислительная сложность, необходимость задания количества кластеров<ref>Нейский И.М. Классификация и сравнение методов кластеризации</ref>.

Алгоритм был разработан J.C. Dunn в 1973 г.<ref> Dunn, J. C. (1973-01-01). "A Fuzzy Relative of the ISODATA Process and Its Use in Detecting Compact Well-Separated Clusters". Journal of Cybernetics. 3 (3): 32–57. doi:10.1080/01969727308546046. ISSN 0022-0280.</ref>, усовершенствован J.C. Bezdek в 1981 г.<ref> Bezdek, James C. (1981). Pattern Recognition with Fuzzy Objective Function Algorithms. ISBN 0-306-40671-3.</ref>.

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

В общем виде алгоритм можно записать следующим образом:

# Инициализировать матрицу принадлежности;
# Вычислить центры кластеров;
# Вычислить значение решающей функции. Если значение ниже некоторого порогового или его улучшение по сравнению с предыдущей итерацией меньше определенной величины, то остановить вычисления;
# Иначе вычислить новые значения матрицы принадлежности;
# Перейти к шагу 2

== Математическое описание алгоритма ==
Рассмотрим матрицу <math> M = m_{ik} \in[0,1],\; i = 1, ..., c, \; k = 1, ..., K </math>. <math>m_{i,k}</math> - вероятность принадлежности объекта <math>k</math> к кластеру <math>i</math>; <math>c</math> - количество кластеров, <math>K</math> - количество векторов. При этом элементы матрицы удовлетворяют следующим условиям:

* сумма элементов в каждом столбце равна <math>1</math>;

* сумма всех элементов матрицы равно <math>K</math>;

Назовем <math> M </math> матрицей принадлежности.

Пусть <math>c_{i} (i = 1,2,...c)</math> - центры кластеров. Тогда рассмотрим функцию

<math>
\begin{align}
J(M, c_{1}, c_{2},...c_{c}) = \sum_{i = 1}^{c}{J_{i}} = \sum_{i = 1}^{c}\sum_{k = 1}^{K}{m_{ik}^q}d_{ik}^2 ~(1)
\end{align}
</math>

где <math> d_{ik} = \left\Vert{u_{k}-c_{i}}\right\| </math> - Евклидово расстояние между центром кластера и объектом, <math> 1 \le q \le \infty </math> - экспоненциальный весовой коэффициент, характеризующий нечеткость. Будем минимизировать значение функции <math> J </math>. Для этого вычислим центры кластеров по формуле <math> ~(2) </math>.

<math>c_{i} = {{\sum_{k = 1}^{K}{m_{ik}^q} * u_{k}} \over {\sum_{k = 1}^{K}{m_{ik}^q}}}~(2)</math>

где <math>m_{ik}</math> — коэффициент принадлежности <math>u_{k}</math> вектора к кластеру <math>c_{i}</math>

и новые значения матрицы <math> M </math> по формуле <math> ~(3) </math>

<math>m_{ik} = {1 \over \sum_{j = 1}^{c}{({{d_{ik}} \over {d_{jk}}})}^{2 \over q-1}} ~(3)</math>

<math> ~(2) </math> и <math> ~(3) </math>являются необходимым условиями достижения минимума функцией <math> J </math>. Таким образом эти два условия дают нам итерационный процесс.

Полностью алгоритм можно записать следующим образом:

# Инициализировать матрицу принадлежности <math> M </math> случайными значениями от 0 до 1;
# Вычислить центры кластеров <math>c_{i} (i = 1,2,...c)</math> используя формулу <math>~(2)</math>;
# Вычислить значение решающей функции по формуле <math>~(1)</math>. Если значение <math> J < \varepsilon,~\varepsilon > 0</math> или <math> |J_{i} - J_{i-1}| < \delta,~\delta > 0 </math>, то остановить вычисления;
# Иначе вычислить новые значения матрицы М по формуле <math>~(3)</math>;
# Перейти к шагу 2

== Вычислительное ядро алгоритма ==
Вычислительным ядром алгоритма являются формулы: <math> (1) </math>, <math> (2) </math>, <math> (3) </math>. В них производится вычисление новых центров кластеров, значения решающей функции и пересчет элементов матрицы принадлежности.

== Макроструктура алгоритма ==
Макроструктура алгоритма состоит из следующих шагов:

# Инициализация матрицы <math> M </math> случайными значениями от 0 до 1;
# Вычисление центров кластеров;
# Вычисление значения решающей функции(если оно удовлетворяет условиям останова - завершение вычислений);
# Вычисление новых элементов матрицы принадлежности;
# Переход к шагу 2;

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

Пример реализации алгоритма на языке С++. Сначала вычислим центры кластеров, потом вычислим решающую функцию, с ее помощью определим необходимость продолжать алгоритм, и при необходимости вычислим новые значения матрицы M.
<source lang="C++">

float ** m;
int *c;
int number_clusters, number_items;
m = gen_random_clusters();//заполним матрицу m случайными значениями от 0 до 1

while (true)
{
//вычисление центров кластеров
for (int i=0; i<number_clusters; i++)
{
numerator==denumerator=0;
for (int k=0; k<number_items; k++)
{
numerator+=pow(m[i, k], q)*u[k];//u[k]-вектор
denumerator+=pow(m[i, k], q);
}
c[i]= numerator / denumerator;//центры кластеров
}

j=0;//вычисление решающей функции
for (int i=0; i<number_clusters; i++)
for (int k=0; k<number_items; k++)
j+=pow(m[i, k], q)*pow(dist(c[i], x[k],2);//dist-вычисляет расстояние между заданными векторами

if ((abs(j-last_j)<delta) || (j<eps)) break;//проверка на необходимость завернешения алгоритма
last_j=j;
//обновление матрицы m
for (int i=0; i<number_clusters; i++)
for (int k=0; k<number_items; k++)
{
m[i,k]=0
for(int j=0; j<number_clusters; j++)
m[i,k]+=pow(dist(c[i], x[k])/dist(c[j], x[k]),2/(q-1));
m[i,k]=1/m[i,k];
}

}
</source>

== Последовательная сложность алгоритма ==
Каждая итерация включает в себя
* Вычисление центров кластеров <math>O(C*K)</math>
* Вычисление решающей функции <math>O(C*K)</math>
* Обновлене матрицы <math>M</math> <math>O(C*C*K)</math>
Общая сложность каждой итерации <math>O(C*C*K)</math>.

Сложность всего алгоритма будет зависеть от числа итераций, которое зависит от
* Выбора начального приближения
* Выбора условий останова

Окончательно, сложность алгоритма будет равна произведению количества итераций на их сложность

== Информационный граф ==
'''Первый ярус''' состоит из <math>C</math> параллельных операций, каждая их которых в свою очередь состоит из <math>K</math> параллельных операций, и одной, которая выполняется с использованием результата предыдущих.
Результатом работы этого яруса являются значения центров кластеров , которые будут использоваться на следующем ярусе.

'''Второй ярус''' содержит в себе <math>C*K</math> параллельных операций.
Результатом его работы является значение решающей функции <math>J</math>. Её значение определяет необходимость завершения алгоритма.

'''Третий ярус''' включает <math>C*K</math> параллельных операций, каждая из которых состоит из <math>C</math> параллельных операций, и одной, которая выполняется с использованием результата предыдущих.

[[Файл:Суперпрак.png|1200px|thumb|center|Информационный граф алгоритма. Салатовым цветом обозначены вершины графа-операции. Дугами обозначена передача информации, передаваемые данные надписаны сверху.]]

== Ресурс параллелизма алгоритма ==
На каждом шаге алгоритма необходимо вычислять сумму элементов массивов. Сложность ее вычисления на первом шаге (вычисление центров кластеров) при параллельной реализации составляет <math>O(\log_{2} C)</math>. Для каждого элемента из набора входных данных(<math> K </math>), но здесь возможен независимый расчет(координатный параллелизм). На втором шаге(вычисление решающей функции) сложность будет <math>O(\log_{2} {C*K})</math>, потому что здесь необходимо сложение всех элементов. На третьем шаге имеем сложность <math>O(\log_{2} C^2)</math>. Итого суммарная сложность итерации: <math>O(\log_{2} {C*K} + \log_{2} C^3)</math>. Воспользовавшись свойствами логарифма произведения получаем: <math>O(\log_{2} {K} + \log_{2} C^4)</math>.

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

== Входные и выходные данные алгоритма ==
Входные данные:
* <math>u_{k} ~k = 1, ..., K</math> - набор входных векторов размерности <math> N </math>;
* <math>C</math> - количество кластеров;
* <math>q</math> - экспоненциальный весовой коэффициент, характеризующий нечеткость;
* <math>\varepsilon > 0, ~\delta > 0</math> - коэффициенты, описывающие точность алгоритма.
Объем входных данных: <math> K*N </math>

Выходные данные:
* <math> M </math> - матрица принадлежности.
Объем выходных данных: <math> C*K </math>

== Свойства алгоритма ==
*Соотношение последовательной и параллельной сложности алгоритма: <math>C*C*K \over {\log_{2} {K} + \log_{2} C^4}</math>. Соответственно при распараллеливании наибольший прирост в производительности мы получим при разбиении большого набора данных на большее число кластеров;
*Вычислительная мощность: <math>{{C^2*K} \over {C*K}} = C</math>. Получается, что на чем большее количество кластеров мы разбиваем набор данных, тем менее затратным становится перемещение данных;
*Алгоритм не является устойчивым, как и другие подобные алгоритмы этого класса(например k-means). Очень многое зависит как от входных данных, так и от изначальных параметров приближения(заполнения матрицы принадлежности => исходных центров кластеров);
*Не является детерминированным. Так же очень многое зависит как от входных данных, так и от изначальных параметров приближения(заполнения матрицы принадлежности => исходных центров кластеров);
*Алгоритм не сбалансирован - доминирует операция умножения. Параллельные ветви алгоритма сбалансированы;
*Степень исхода вершины информационного графа - 2.

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

Проведём исследование масштабируемости параллельной реализации разложения Холецкого согласно [[Scalability methodology|методике]]. Исследование проводилось на суперкомпьютере "Ломоносов"<ref name="Lom">Воеводин Вл., Жуматий С., Соболев С., Антонов А., Брызгалов П., Никитенко Д., Стефанов К., Воеводин Вад. Практика суперкомпьютера «Ломоносов» // Открытые системы, 2012, N 7, С. 36-39.</ref> [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета].

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

* число процессоров [1 : 120];
* размер входных данных [1 : 15 000] векторов размерности 4.
При количестве кластеров 100.

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

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

В параллельной реализации использовалась технология OpenMP. Компилятор GNU(gcc) с флагом -fopenmp. Версия компилятора: gcc version 4.4.7 20120313 (Red Hat 4.4.7-4) (GCC).

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

[[file: FCM произв.jpg |thumb|center|800px|Изменение производительности.]]

[[file: FCM эф.jpg |thumb|center|800px|Изменение эффективности.]]

Оценки масштабируемости:
* По числу процессов: 0.1245.
* По размеру задачи: -0.0278.
* По двум направлениям: 0,00009.

[http://pastebin.com/LDPNY5Ua Параллельная реализация на языке С с использованием Open MP]

== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Можно найти следующие реализации алгоритма
* Для MATLAB http://www.mathworks.com/help/fuzzy/fcm.html
* В PostgreSQL http://num-meth.srcc.msu.ru/zhurnal/tom_2012/v13r207.html
Так же готовые реализации алгоритма и его описание можно найти на сайтах
* https://habrahabr.ru/post/208496/
* http://pythonhosted.org/scikit-fuzzy/auto_examples/plot_cmeans.html
* http://www.codeproject.com/Articles/91675/Computer-Vision-Applications-with-C-Fuzzy-C-means
* https://github.com/gyaikhom/fcm

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

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

2016-11-19T21:34:18Z

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

{{algorithm
| name = Нечеткий алгоритм C средних
| serial_complexity = <math>O(C*C*K*I)</math>., где <math>I</math> - количество итераций
| input_data = <math>K*N</math>, [количество векторов * размерность]
| output_data = <math>C*K</math>, [элементы матрицы принадлежности]
| pf_height = <math>3I</math>
| pf_width = <math>C*C*K</math>
}}

Авторы : [[Участник:Protsenko|Мария Проценко]] (1.5-1.8, 2.7), [[Участник:ADovganich|Андрей Довганич]] (1.1-1.4, 1.9, 1.10)

= Свойства и структура алгоритмов =
== Общее описание алгоритма ==
Нечеткий алгоритм C-средних (fuzzy C-means) позволяет разбить имеющееся множество векторов (точек) мощностью <math>K</math> на заданное число нечетких множеств. Предназначен для кластеризации больших наборов данных. Основным достоинством алгоритма является нечеткость при определении объекта в кластер. Благодаря этому становится возможным определить объекты, которые находятся на границе, в кластеры. Из основного достоинства следует и главный недостаток - неопределенность с объектами, удаленными от центров всех кластеров. В остальном ему присущи стандартные проблемы подобного класса алгоритмов: вычислительная сложность, необходимость задания количества кластеров<ref>Нейский И.М. Классификация и сравнение методов кластеризации</ref>.

Алгоритм был разработан J.C. Dunn в 1973 г.<ref> Dunn, J. C. (1973-01-01). "A Fuzzy Relative of the ISODATA Process and Its Use in Detecting Compact Well-Separated Clusters". Journal of Cybernetics. 3 (3): 32–57. doi:10.1080/01969727308546046. ISSN 0022-0280.</ref>, усовершенствован J.C. Bezdek в 1981 г.<ref> Bezdek, James C. (1981). Pattern Recognition with Fuzzy Objective Function Algorithms. ISBN 0-306-40671-3.</ref>.

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

В общем виде алгоритм можно записать следующим образом:

# Инициализировать матрицу принадлежности;
# Вычислить центры кластеров;
# Вычислить значение решающей функции. Если значение ниже некоторого порогового или его улучшение по сравнению с предыдущей итерацией меньше определенной величины, то остановить вычисления;
# Иначе вычислить новые значения матрицы принадлежности;
# Перейти к шагу 2

== Математическое описание алгоритма ==
Рассмотрим матрицу <math> M = m_{ik} \in[0,1],\; i = 1, ..., c, \; k = 1, ..., K </math>. <math>m_{i,k}</math> - вероятность принадлежности объекта <math>k</math> к кластеру <math>i</math>; <math>c</math> - количество кластеров, <math>K</math> - количество векторов. При этом элементы матрицы удовлетворяют следующим условиям:

* сумма элементов в каждом столбце равна <math>1</math>;

* сумма всех элементов матрицы равно <math>K</math>;

Назовем <math> M </math> матрицей принадлежности.

Пусть <math>c_{i} (i = 1,2,...c)</math> - центры кластеров. Тогда рассмотрим функцию

<math>
\begin{align}
J(M, c_{1}, c_{2},...c_{c}) = \sum_{i = 1}^{c}{J_{i}} = \sum_{i = 1}^{c}\sum_{k = 1}^{K}{m_{ik}^q}d_{ik}^2 ~(1)
\end{align}
</math>

где <math> d_{ik} = \left\Vert{u_{k}-c_{i}}\right\| </math> - Евклидово расстояние между центром кластера и объектом, <math> 1 \le q \le \infty </math> - экспоненциальный весовой коэффициент, характеризующий нечеткость. Будем минимизировать значение функции <math> J </math>. Для этого вычислим центры кластеров по формуле <math> ~(2) </math>.

<math>c_{i} = {{\sum_{k = 1}^{K}{m_{ik}^q} * u_{k}} \over {\sum_{k = 1}^{K}{m_{ik}^q}}}~(2)</math>

где <math>m_{ik}</math> — коэффициент принадлежности <math>u_{k}</math> вектора к кластеру <math>c_{i}</math>

и новые значения матрицы <math> M </math> по формуле <math> ~(3) </math>

<math>m_{ik} = {1 \over \sum_{j = 1}^{c}{({{d_{ik}} \over {d_{jk}}})}^{2 \over q-1}} ~(3)</math>

<math> ~(2) </math> и <math> ~(3) </math>являются необходимым условиями достижения минимума функцией <math> J </math>. Таким образом эти два условия дают нам итерационный процесс.

Полностью алгоритм можно записать следующим образом:

# Инициализировать матрицу принадлежности <math> M </math> случайными значениями от 0 до 1;
# Вычислить центры кластеров <math>c_{i} (i = 1,2,...c)</math> используя формулу <math>~(2)</math>;
# Вычислить значение решающей функции по формуле <math>~(1)</math>. Если значение <math> J < \varepsilon,~\varepsilon > 0</math> или <math> |J_{i} - J_{i-1}| < \delta,~\delta > 0 </math>, то остановить вычисления;
# Иначе вычислить новые значения матрицы М по формуле <math>~(3)</math>;
# Перейти к шагу 2

== Вычислительное ядро алгоритма ==
Вычислительным ядром алгоритма являются формулы: <math> (1) </math>, <math> (2) </math>, <math> (3) </math>. В них производится вычисление новых центров кластеров, значения решающей функции и пересчет элементов матрицы принадлежности.

== Макроструктура алгоритма ==
Макроструктура алгоритма состоит из следующих шагов:

# Инициализация матрицы <math> M </math> случайными значениями от 0 до 1;
# Вычисление центров кластеров;
# Вычисление значения решающей функции(если оно удовлетворяет условиям останова - завершение вычислений);
# Вычисление новых элементов матрицы принадлежности;
# Переход к шагу 2;

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

Пример реализации алгоритма на языке С++. Сначала вычислим центры кластеров, потом вычислим решающую функцию, с ее помощью определим необходимость продолжать алгоритм, и при необходимости вычислим новые значения матрицы M.
<source lang="C++">

float ** m;
int *c;
int number_clusters, number_items;
m = gen_random_clusters();//заполним матрицу m случайными значениями от 0 до 1

while (true)
{
//вычисление центров кластеров
for (int i=0; i<number_clusters; i++)
{
numerator==denumerator=0;
for (int k=0; k<number_items; k++)
{
numerator+=pow(m[i, k], q)*u[k];//u[k]-вектор
denumerator+=pow(m[i, k], q);
}
c[i]= numerator / denumerator;//центры кластеров
}

j=0;//вычисление решающей функции
for (int i=0; i<number_clusters; i++)
for (int k=0; k<number_items; k++)
j+=pow(m[i, k], q)*pow(dist(c[i], x[k],2);//dist-вычисляет расстояние между заданными векторами

if ((abs(j-last_j)<delta) || (j<eps)) break;//проверка на необходимость завернешения алгоритма
last_j=j;
//обновление матрицы m
for (int i=0; i<number_clusters; i++)
for (int k=0; k<number_items; k++)
{
m[i,k]=0
for(int j=0; j<number_clusters; j++)
m[i,k]+=pow(dist(c[i], x[k])/dist(c[j], x[k]),2/(q-1));
m[i,k]=1/m[i,k];
}

}
</source>

== Последовательная сложность алгоритма ==
Каждая итерация включает в себя
* Вычисление центров кластеров <math>O(C*K)</math>
* Вычисление решающей функции <math>O(C*K)</math>
* Обновлене матрицы <math>M</math> <math>O(C*C*K)</math>
Общая сложность каждой итерации <math>O(C*C*K)</math>.

Сложность всего алгоритма будет зависеть от числа итераций, которое зависит от
* Выбора начального приближения
* Выбора условий останова

Окончательно, сложность алгоритма будет равна произведению количества итераций на их сложность

== Информационный граф ==
'''Первый ярус''' состоит из <math>C</math> параллельных операций, каждая их которых в свою очередь состоит из <math>K</math> параллельных операций, и одной, которая выполняется с использованием результата предыдущих.
Результатом работы этого яруса являются значения центров кластеров , которые будут использоваться на следующем ярусе.

'''Второй ярус''' содержит в себе <math>C*K</math> параллельных операций.
Результатом его работы является значение решающей функции <math>J</math>. Её значение определяет необходимость завершения алгоритма.

'''Третий ярус''' включает <math>C*K</math> параллельных операций, каждая из которых состоит из <math>C</math> параллельных операций, и одной, которая выполняется с использованием результата предыдущих.

[[Файл:Суперпрак.png|1200px|thumb|center|Информационный граф алгоритма. Салатовым цветом обозначены вершины графа-операции. Дугами обозначена передача информации, передаваемые данные надписаны сверху.]]

== Ресурс параллелизма алгоритма ==
На каждом шаге алгоритма необходимо вычислять сумму элементов массивов. Сложность ее вычисления на первом шаге (вычисление центров кластеров) при параллельной реализации составляет <math>O(\log_{2} C)</math>. Для каждого элемента из набора входных данных(<math> K </math>), но здесь возможен независимый расчет(координатный параллелизм). На втором шаге(вычисление решающей функции) сложность будет <math>O(\log_{2} {C*K})</math>, потому что здесь необходимо сложение всех элементов. На третьем шаге имеем сложность <math>O(\log_{2} C^2)</math>. Итого суммарная сложность итерации: <math>O(\log_{2} {C*K} + \log_{2} C^3)</math>. Воспользовавшись свойствами логарифма произведения получаем: <math>O(\log_{2} {K} + \log_{2} C^4)</math>.

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

== Входные и выходные данные алгоритма ==
Входные данные:
* <math>u_{k} ~k = 1, ..., K</math> - набор входных векторов размерности <math> N </math>;
* <math>C</math> - количество кластеров;
* <math>q</math> - экспоненциальный весовой коэффициент, характеризующий нечеткость;
* <math>\varepsilon > 0, ~\delta > 0</math> - коэффициенты, описывающие точность алгоритма.
Объем входных данных: <math> K*N </math>

Выходные данные:
* <math> M </math> - матрица принадлежности.
Объем выходных данных: <math> C*K </math>

== Свойства алгоритма ==
*Соотношение последовательной и параллельной сложности алгоритма: <math>C*C*K \over {\log_{2} {K} + \log_{2} C^4}</math>. Соответственно при распараллеливании наибольший прирост в производительности мы получим при разбиении большого набора данных на большее число кластеров;
*Вычислительная мощность: <math>{{C^2*K} \over {C*K}} = C</math>. Получается, что на чем большее количество кластеров мы разбиваем набор данных, тем менее затратным становится перемещение данных;
*Алгоритм не является устойчивым, как и другие подобные алгоритмы этого класса(например k-means). Очень многое зависит как от входных данных, так и от изначальных параметров приближения(заполнения матрицы принадлежности => исходных центров кластеров);
*Не является детерминированным. Так же очень многое зависит как от входных данных, так и от изначальных параметров приближения(заполнения матрицы принадлежности => исходных центров кластеров);
*Алгоритм не сбалансирован - доминирует операция умножения. Параллельные ветви алгоритма сбалансированы;
*Степень исхода вершины информационного графа - 2.

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

Проведём исследование масштабируемости параллельной реализации разложения Холецкого согласно [[Scalability methodology|методике]]. Исследование проводилось на суперкомпьютере "Ломоносов"<ref name="Lom">Воеводин Вл., Жуматий С., Соболев С., Антонов А., Брызгалов П., Никитенко Д., Стефанов К., Воеводин Вад. Практика суперкомпьютера «Ломоносов» // Открытые системы, 2012, N 7, С. 36-39.</ref> [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета].

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

* число процессоров [1 : 120];
* размер входных данных [1 : 15 000] векторов размерности 4.
При количестве кластеров 100.

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

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

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

[[file: FCM произв.jpg |thumb|center|800px|Изменение производительности.]]

[[file: FCM эф.jpg |thumb|center|800px|Изменение эффективности.]]

[http://pastebin.com/LDPNY5Ua Параллельная реализация на языке С с использованием Open MP]

== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Можно найти следующие реализации алгоритма
* Для MATLAB http://www.mathworks.com/help/fuzzy/fcm.html
* В PostgreSQL http://num-meth.srcc.msu.ru/zhurnal/tom_2012/v13r207.html
Так же готовые реализации алгоритма и его описание можно найти на сайтах
* https://habrahabr.ru/post/208496/
* http://pythonhosted.org/scikit-fuzzy/auto_examples/plot_cmeans.html
* http://www.codeproject.com/Articles/91675/Computer-Vision-Applications-with-C-Fuzzy-C-means
* https://github.com/gyaikhom/fcm

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

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

2016-11-19T21:33:38Z

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

{{algorithm
| name = Нечеткий алгоритм C средних
| serial_complexity = <math>O(C*C*K*I)</math>., где <math>I</math> - количество итераций
| input_data = <math>K*N</math>, [количество векторов * размерность]
| output_data = <math>C*K</math>, [элементы матрицы принадлежности]
| pf_height = <math>3I</math>
| pf_width = <math>C*C*K</math>
}}

Авторы : [[Участник:Protsenko|Мария Проценко]] (1.5-1.8, 2.7), [[Участник:ADovganich|Андрей Довганич]] (1.1-1.4, 1.9, 1.10)

= Свойства и структура алгоритмов =
== Общее описание алгоритма ==
Нечеткий алгоритм C-средних (fuzzy C-means) позволяет разбить имеющееся множество векторов (точек) мощностью <math>K</math> на заданное число нечетких множеств. Предназначен для кластеризации больших наборов данных. Основным достоинством алгоритма является нечеткость при определении объекта в кластер. Благодаря этому становится возможным определить объекты, которые находятся на границе, в кластеры. Из основного достоинства следует и главный недостаток - неопределенность с объектами, удаленными от центров всех кластеров. В остальном ему присущи стандартные проблемы подобного класса алгоритмов: вычислительная сложность, необходимость задания количества кластеров<ref>Нейский И.М. Классификация и сравнение методов кластеризации</ref>.

Алгоритм был разработан J.C. Dunn в 1973 г.<ref> Dunn, J. C. (1973-01-01). "A Fuzzy Relative of the ISODATA Process and Its Use in Detecting Compact Well-Separated Clusters". Journal of Cybernetics. 3 (3): 32–57. doi:10.1080/01969727308546046. ISSN 0022-0280.</ref>, усовершенствован J.C. Bezdek в 1981 г.<ref> Bezdek, James C. (1981). Pattern Recognition with Fuzzy Objective Function Algorithms. ISBN 0-306-40671-3.</ref>.

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

В общем виде алгоритм можно записать следующим образом:

# Инициализировать матрицу принадлежности;
# Вычислить центры кластеров;
# Вычислить значение решающей функции. Если значение ниже некоторого порогового или его улучшение по сравнению с предыдущей итерацией меньше определенной величины, то остановить вычисления;
# Иначе вычислить новые значения матрицы принадлежности;
# Перейти к шагу 2

== Математическое описание алгоритма ==
Рассмотрим матрицу <math> M = m_{ik} \in[0,1],\; i = 1, ..., c, \; k = 1, ..., K </math>. <math>m_{i,k}</math> - вероятность принадлежности объекта <math>k</math> к кластеру <math>i</math>; <math>c</math> - количество кластеров, <math>K</math> - количество векторов. При этом элементы матрицы удовлетворяют следующим условиям:

* сумма элементов в каждом столбце равна <math>1</math>;

* сумма всех элементов матрицы равно <math>K</math>;

Назовем <math> M </math> матрицей принадлежности.

Пусть <math>c_{i} (i = 1,2,...c)</math> - центры кластеров. Тогда рассмотрим функцию

<math>
\begin{align}
J(M, c_{1}, c_{2},...c_{c}) = \sum_{i = 1}^{c}{J_{i}} = \sum_{i = 1}^{c}\sum_{k = 1}^{K}{m_{ik}^q}d_{ik}^2 ~(1)
\end{align}
</math>

где <math> d_{ik} = \left\Vert{u_{k}-c_{i}}\right\| </math> - Евклидово расстояние между центром кластера и объектом, <math> 1 \le q \le \infty </math> - экспоненциальный весовой коэффициент, характеризующий нечеткость. Будем минимизировать значение функции <math> J </math>. Для этого вычислим центры кластеров по формуле <math> ~(2) </math>.

<math>c_{i} = {{\sum_{k = 1}^{K}{m_{ik}^q} * u_{k}} \over {\sum_{k = 1}^{K}{m_{ik}^q}}}~(2)</math>

где <math>m_{ik}</math> — коэффициент принадлежности <math>u_{k}</math> вектора к кластеру <math>c_{i}</math>

и новые значения матрицы <math> M </math> по формуле <math> ~(3) </math>

<math>m_{ik} = {1 \over \sum_{j = 1}^{c}{({{d_{ik}} \over {d_{jk}}})}^{2 \over q-1}} ~(3)</math>

<math> ~(2) </math> и <math> ~(3) </math>являются необходимым условиями достижения минимума функцией <math> J </math>. Таким образом эти два условия дают нам итерационный процесс.

Полностью алгоритм можно записать следующим образом:

# Инициализировать матрицу принадлежности <math> M </math> случайными значениями от 0 до 1;
# Вычислить центры кластеров <math>c_{i} (i = 1,2,...c)</math> используя формулу <math>~(2)</math>;
# Вычислить значение решающей функции по формуле <math>~(1)</math>. Если значение <math> J < \varepsilon,~\varepsilon > 0</math> или <math> |J_{i} - J_{i-1}| < \delta,~\delta > 0 </math>, то остановить вычисления;
# Иначе вычислить новые значения матрицы М по формуле <math>~(3)</math>;
# Перейти к шагу 2

== Вычислительное ядро алгоритма ==
Вычислительным ядром алгоритма являются формулы: <math> (1) </math>, <math> (2) </math>, <math> (3) </math>. В них производится вычисление новых центров кластеров, значения решающей функции и пересчет элементов матрицы принадлежности.

== Макроструктура алгоритма ==
Макроструктура алгоритма состоит из следующих шагов:

# Инициализация матрицы <math> M </math> случайными значениями от 0 до 1;
# Вычисление центров кластеров;
# Вычисление значения решающей функции(если оно удовлетворяет условиям останова - завершение вычислений);
# Вычисление новых элементов матрицы принадлежности;
# Переход к шагу 2;

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

Пример реализации алгоритма на языке С++. Сначала вычислим центры кластеров, потом вычислим решающую функцию, с ее помощью определим необходимость продолжать алгоритм, и при необходимости вычислим новые значения матрицы M.
<source lang="C++">

float ** m;
int *c;
int number_clusters, number_items;
m = gen_random_clusters();//заполним матрицу m случайными значениями от 0 до 1

while (true)
{
//вычисление центров кластеров
for (int i=0; i<number_clusters; i++)
{
numerator==denumerator=0;
for (int k=0; k<number_items; k++)
{
numerator+=pow(m[i, k], q)*u[k];//u[k]-вектор
denumerator+=pow(m[i, k], q);
}
c[i]= numerator / denumerator;//центры кластеров
}

j=0;//вычисление решающей функции
for (int i=0; i<number_clusters; i++)
for (int k=0; k<number_items; k++)
j+=pow(m[i, k], q)*pow(dist(c[i], x[k],2);//dist-вычисляет расстояние между заданными векторами

if ((abs(j-last_j)<delta) || (j<eps)) break;//проверка на необходимость завернешения алгоритма
last_j=j;
//обновление матрицы m
for (int i=0; i<number_clusters; i++)
for (int k=0; k<number_items; k++)
{
m[i,k]=0
for(int j=0; j<number_clusters; j++)
m[i,k]+=pow(dist(c[i], x[k])/dist(c[j], x[k]),2/(q-1));
m[i,k]=1/m[i,k];
}

}
</source>

== Последовательная сложность алгоритма ==
Каждая итерация включает в себя
* Вычисление центров кластеров <math>O(C*K)</math>
* Вычисление решающей функции <math>O(C*K)</math>
* Обновлене матрицы <math>M</math> <math>O(C*C*K)</math>
Общая сложность каждой итерации <math>O(C*C*K)</math>.

Сложность всего алгоритма будет зависеть от числа итераций, которое зависит от
* Выбора начального приближения
* Выбора условий останова

Окончательно, сложность алгоритма будет равна произведению количества итераций на их сложность

== Информационный граф ==
'''Первый ярус''' состоит из <math>C</math> параллельных операций, каждая их которых в свою очередь состоит из <math>K</math> параллельных операций, и одной, которая выполняется с использованием результата предыдущих.
Результатом работы этого яруса являются значения центров кластеров , которые будут использоваться на следующем ярусе.

'''Второй ярус''' содержит в себе <math>C*K</math> параллельных операций.
Результатом его работы является значение решающей функции <math>J</math>. Её значение определяет необходимость завершения алгоритма.

'''Третий ярус''' включает <math>C*K</math> параллельных операций, каждая из которых состоит из <math>C</math> параллельных операций, и одной, которая выполняется с использованием результата предыдущих.

[[Файл:Суперпрак.png|1200px|thumb|center|Информационный граф алгоритма. Салатовым цветом обозначены вершины графа-операции. Дугами обозначена передача информации, передаваемые данные надписаны сверху.]]

== Ресурс параллелизма алгоритма ==
На каждом шаге алгоритма необходимо вычислять сумму элементов массивов. Сложность ее вычисления на первом шаге (вычисление центров кластеров) при параллельной реализации составляет <math>O(\log_{2} C)</math>. Для каждого элемента из набора входных данных(<math> K </math>), но здесь возможен независимый расчет(координатный параллелизм). На втором шаге(вычисление решающей функции) сложность будет <math>O(\log_{2} {C*K})</math>, потому что здесь необходимо сложение всех элементов. На третьем шаге имеем сложность <math>O(\log_{2} C^2)</math>. Итого суммарная сложность итерации: <math>O(\log_{2} {C*K} + \log_{2} C^3)</math>. Воспользовавшись свойствами логарифма произведения получаем: <math>O(\log_{2} {K} + \log_{2} C^4)</math>.

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

== Входные и выходные данные алгоритма ==
Входные данные:
* <math>u_{k} ~k = 1, ..., K</math> - набор входных векторов размерности <math> N </math>;
* <math>C</math> - количество кластеров;
* <math>q</math> - экспоненциальный весовой коэффициент, характеризующий нечеткость;
* <math>\varepsilon > 0, ~\delta > 0</math> - коэффициенты, описывающие точность алгоритма.
Объем входных данных: <math> K*N </math>

Выходные данные:
* <math> M </math> - матрица принадлежности.
Объем выходных данных: <math> C*K </math>

== Свойства алгоритма ==
*Соотношение последовательной и параллельной сложности алгоритма: <math>C*C*K \over {\log_{2} {K} + \log_{2} C^4}</math>. Соответственно при распараллеливании наибольший прирост в производительности мы получим при разбиении большого набора данных на большее число кластеров;
*Вычислительная мощность: <math>{{C^2*K} \over {C*K}} = C</math>. Получается, что на чем большее количество кластеров мы разбиваем набор данных, тем менее затратным становится перемещение данных;
*Алгоритм не является устойчивым, как и другие подобные алгоритмы этого класса(например k-means). Очень многое зависит как от входных данных, так и от изначальных параметров приближения(заполнения матрицы принадлежности => исходных центров кластеров);
*Не является детерминированным. Так же очень многое зависит как от входных данных, так и от изначальных параметров приближения(заполнения матрицы принадлежности => исходных центров кластеров);
*Алгоритм не сбалансирован - доминирует операция умножения. Параллельные ветви алгоритма сбалансированы;
*Степень исхода вершины информационного графа - 2.

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

Проведём исследование масштабируемости параллельной реализации разложения Холецкого согласно [[Scalability methodology|методике]]. Исследование проводилось на суперкомпьютере "Ломоносов"<ref name="Lom">Воеводин Вл., Жуматий С., Соболев С., Антонов А., Брызгалов П., Никитенко Д., Стефанов К., Воеводин Вад. Практика суперкомпьютера «Ломоносов» // Открытые системы, 2012, N 7, С. 36-39.</ref> [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета].

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

* число процессоров [1 : 120];
* размер входных данных [1 : 15 000] векторов размерности 4.
При количестве кластеров 100.

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

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

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

[[file: FCM произв.jpg |thumb|center|Изменение производительности.]]

[[file: FCM эф.jpg |thumb|center|Изменение эффективности.]]

[http://pastebin.com/LDPNY5Ua Параллельная реализация на языке С с использованием Open MP]

== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Можно найти следующие реализации алгоритма
* Для MATLAB http://www.mathworks.com/help/fuzzy/fcm.html
* В PostgreSQL http://num-meth.srcc.msu.ru/zhurnal/tom_2012/v13r207.html
Так же готовые реализации алгоритма и его описание можно найти на сайтах
* https://habrahabr.ru/post/208496/
* http://pythonhosted.org/scikit-fuzzy/auto_examples/plot_cmeans.html
* http://www.codeproject.com/Articles/91675/Computer-Vision-Applications-with-C-Fuzzy-C-means
* https://github.com/gyaikhom/fcm

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

Файл:FCM произв.jpg

2016-11-19T21:32:51Z

Protsenko:

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

2016-11-19T21:26:25Z

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

{{algorithm
| name = Нечеткий алгоритм C средних
| serial_complexity = <math>O(C*C*K*I)</math>., где <math>I</math> - количество итераций
| input_data = <math>K*N</math>, [количество векторов * размерность]
| output_data = <math>C*K</math>, [элементы матрицы принадлежности]
| pf_height = <math>3I</math>
| pf_width = <math>C*C*K</math>
}}

Авторы : [[Участник:Protsenko|Мария Проценко]] (1.5-1.8, 2.7), [[Участник:ADovganich|Андрей Довганич]] (1.1-1.4, 1.9, 1.10)

= Свойства и структура алгоритмов =
== Общее описание алгоритма ==
Нечеткий алгоритм C-средних (fuzzy C-means) позволяет разбить имеющееся множество векторов (точек) мощностью <math>K</math> на заданное число нечетких множеств. Предназначен для кластеризации больших наборов данных. Основным достоинством алгоритма является нечеткость при определении объекта в кластер. Благодаря этому становится возможным определить объекты, которые находятся на границе, в кластеры. Из основного достоинства следует и главный недостаток - неопределенность с объектами, удаленными от центров всех кластеров. В остальном ему присущи стандартные проблемы подобного класса алгоритмов: вычислительная сложность, необходимость задания количества кластеров<ref>Нейский И.М. Классификация и сравнение методов кластеризации</ref>.

Алгоритм был разработан J.C. Dunn в 1973 г.<ref> Dunn, J. C. (1973-01-01). "A Fuzzy Relative of the ISODATA Process and Its Use in Detecting Compact Well-Separated Clusters". Journal of Cybernetics. 3 (3): 32–57. doi:10.1080/01969727308546046. ISSN 0022-0280.</ref>, усовершенствован J.C. Bezdek в 1981 г.<ref> Bezdek, James C. (1981). Pattern Recognition with Fuzzy Objective Function Algorithms. ISBN 0-306-40671-3.</ref>.

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

В общем виде алгоритм можно записать следующим образом:

# Инициализировать матрицу принадлежности;
# Вычислить центры кластеров;
# Вычислить значение решающей функции. Если значение ниже некоторого порогового или его улучшение по сравнению с предыдущей итерацией меньше определенной величины, то остановить вычисления;
# Иначе вычислить новые значения матрицы принадлежности;
# Перейти к шагу 2

== Математическое описание алгоритма ==
Рассмотрим матрицу <math> M = m_{ik} \in[0,1],\; i = 1, ..., c, \; k = 1, ..., K </math>. <math>m_{i,k}</math> - вероятность принадлежности объекта <math>k</math> к кластеру <math>i</math>; <math>c</math> - количество кластеров, <math>K</math> - количество векторов. При этом элементы матрицы удовлетворяют следующим условиям:

* сумма элементов в каждом столбце равна <math>1</math>;

* сумма всех элементов матрицы равно <math>K</math>;

Назовем <math> M </math> матрицей принадлежности.

Пусть <math>c_{i} (i = 1,2,...c)</math> - центры кластеров. Тогда рассмотрим функцию

<math>
\begin{align}
J(M, c_{1}, c_{2},...c_{c}) = \sum_{i = 1}^{c}{J_{i}} = \sum_{i = 1}^{c}\sum_{k = 1}^{K}{m_{ik}^q}d_{ik}^2 ~(1)
\end{align}
</math>

где <math> d_{ik} = \left\Vert{u_{k}-c_{i}}\right\| </math> - Евклидово расстояние между центром кластера и объектом, <math> 1 \le q \le \infty </math> - экспоненциальный весовой коэффициент, характеризующий нечеткость. Будем минимизировать значение функции <math> J </math>. Для этого вычислим центры кластеров по формуле <math> ~(2) </math>.

<math>c_{i} = {{\sum_{k = 1}^{K}{m_{ik}^q} * u_{k}} \over {\sum_{k = 1}^{K}{m_{ik}^q}}}~(2)</math>

где <math>m_{ik}</math> — коэффициент принадлежности <math>u_{k}</math> вектора к кластеру <math>c_{i}</math>

и новые значения матрицы <math> M </math> по формуле <math> ~(3) </math>

<math>m_{ik} = {1 \over \sum_{j = 1}^{c}{({{d_{ik}} \over {d_{jk}}})}^{2 \over q-1}} ~(3)</math>

<math> ~(2) </math> и <math> ~(3) </math>являются необходимым условиями достижения минимума функцией <math> J </math>. Таким образом эти два условия дают нам итерационный процесс.

Полностью алгоритм можно записать следующим образом:

# Инициализировать матрицу принадлежности <math> M </math> случайными значениями от 0 до 1;
# Вычислить центры кластеров <math>c_{i} (i = 1,2,...c)</math> используя формулу <math>~(2)</math>;
# Вычислить значение решающей функции по формуле <math>~(1)</math>. Если значение <math> J < \varepsilon,~\varepsilon > 0</math> или <math> |J_{i} - J_{i-1}| < \delta,~\delta > 0 </math>, то остановить вычисления;
# Иначе вычислить новые значения матрицы М по формуле <math>~(3)</math>;
# Перейти к шагу 2

== Вычислительное ядро алгоритма ==
Вычислительным ядром алгоритма являются формулы: <math> (1) </math>, <math> (2) </math>, <math> (3) </math>. В них производится вычисление новых центров кластеров, значения решающей функции и пересчет элементов матрицы принадлежности.

== Макроструктура алгоритма ==
Макроструктура алгоритма состоит из следующих шагов:

# Инициализация матрицы <math> M </math> случайными значениями от 0 до 1;
# Вычисление центров кластеров;
# Вычисление значения решающей функции(если оно удовлетворяет условиям останова - завершение вычислений);
# Вычисление новых элементов матрицы принадлежности;
# Переход к шагу 2;

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

Пример реализации алгоритма на языке С++. Сначала вычислим центры кластеров, потом вычислим решающую функцию, с ее помощью определим необходимость продолжать алгоритм, и при необходимости вычислим новые значения матрицы M.
<source lang="C++">

float ** m;
int *c;
int number_clusters, number_items;
m = gen_random_clusters();//заполним матрицу m случайными значениями от 0 до 1

while (true)
{
//вычисление центров кластеров
for (int i=0; i<number_clusters; i++)
{
numerator==denumerator=0;
for (int k=0; k<number_items; k++)
{
numerator+=pow(m[i, k], q)*u[k];//u[k]-вектор
denumerator+=pow(m[i, k], q);
}
c[i]= numerator / denumerator;//центры кластеров
}

j=0;//вычисление решающей функции
for (int i=0; i<number_clusters; i++)
for (int k=0; k<number_items; k++)
j+=pow(m[i, k], q)*pow(dist(c[i], x[k],2);//dist-вычисляет расстояние между заданными векторами

if ((abs(j-last_j)<delta) || (j<eps)) break;//проверка на необходимость завернешения алгоритма
last_j=j;
//обновление матрицы m
for (int i=0; i<number_clusters; i++)
for (int k=0; k<number_items; k++)
{
m[i,k]=0
for(int j=0; j<number_clusters; j++)
m[i,k]+=pow(dist(c[i], x[k])/dist(c[j], x[k]),2/(q-1));
m[i,k]=1/m[i,k];
}

}
</source>

== Последовательная сложность алгоритма ==
Каждая итерация включает в себя
* Вычисление центров кластеров <math>O(C*K)</math>
* Вычисление решающей функции <math>O(C*K)</math>
* Обновлене матрицы <math>M</math> <math>O(C*C*K)</math>
Общая сложность каждой итерации <math>O(C*C*K)</math>.

Сложность всего алгоритма будет зависеть от числа итераций, которое зависит от
* Выбора начального приближения
* Выбора условий останова

Окончательно, сложность алгоритма будет равна произведению количества итераций на их сложность

== Информационный граф ==
'''Первый ярус''' состоит из <math>C</math> параллельных операций, каждая их которых в свою очередь состоит из <math>K</math> параллельных операций, и одной, которая выполняется с использованием результата предыдущих.
Результатом работы этого яруса являются значения центров кластеров , которые будут использоваться на следующем ярусе.

'''Второй ярус''' содержит в себе <math>C*K</math> параллельных операций.
Результатом его работы является значение решающей функции <math>J</math>. Её значение определяет необходимость завершения алгоритма.

'''Третий ярус''' включает <math>C*K</math> параллельных операций, каждая из которых состоит из <math>C</math> параллельных операций, и одной, которая выполняется с использованием результата предыдущих.

[[Файл:Суперпрак.png|1200px|thumb|center|Информационный граф алгоритма. Салатовым цветом обозначены вершины графа-операции. Дугами обозначена передача информации, передаваемые данные надписаны сверху.]]

== Ресурс параллелизма алгоритма ==
На каждом шаге алгоритма необходимо вычислять сумму элементов массивов. Сложность ее вычисления на первом шаге (вычисление центров кластеров) при параллельной реализации составляет <math>O(\log_{2} C)</math>. Для каждого элемента из набора входных данных(<math> K </math>), но здесь возможен независимый расчет(координатный параллелизм). На втором шаге(вычисление решающей функции) сложность будет <math>O(\log_{2} {C*K})</math>, потому что здесь необходимо сложение всех элементов. На третьем шаге имеем сложность <math>O(\log_{2} C^2)</math>. Итого суммарная сложность итерации: <math>O(\log_{2} {C*K} + \log_{2} C^3)</math>. Воспользовавшись свойствами логарифма произведения получаем: <math>O(\log_{2} {K} + \log_{2} C^4)</math>.

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

== Входные и выходные данные алгоритма ==
Входные данные:
* <math>u_{k} ~k = 1, ..., K</math> - набор входных векторов размерности <math> N </math>;
* <math>C</math> - количество кластеров;
* <math>q</math> - экспоненциальный весовой коэффициент, характеризующий нечеткость;
* <math>\varepsilon > 0, ~\delta > 0</math> - коэффициенты, описывающие точность алгоритма.
Объем входных данных: <math> K*N </math>

Выходные данные:
* <math> M </math> - матрица принадлежности.
Объем выходных данных: <math> C*K </math>

== Свойства алгоритма ==
*Соотношение последовательной и параллельной сложности алгоритма: <math>C*C*K \over {\log_{2} {K} + \log_{2} C^4}</math>. Соответственно при распараллеливании наибольший прирост в производительности мы получим при разбиении большого набора данных на большее число кластеров;
*Вычислительная мощность: <math>{{C^2*K} \over {C*K}} = C</math>. Получается, что на чем большее количество кластеров мы разбиваем набор данных, тем менее затратным становится перемещение данных;
*Алгоритм не является устойчивым, как и другие подобные алгоритмы этого класса(например k-means). Очень многое зависит как от входных данных, так и от изначальных параметров приближения(заполнения матрицы принадлежности => исходных центров кластеров);
*Не является детерминированным. Так же очень многое зависит как от входных данных, так и от изначальных параметров приближения(заполнения матрицы принадлежности => исходных центров кластеров);
*Алгоритм не сбалансирован - доминирует операция умножения. Параллельные ветви алгоритма сбалансированы;
*Степень исхода вершины информационного графа - 2.

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

Проведём исследование масштабируемости параллельной реализации разложения Холецкого согласно [[Scalability methodology|методике]]. Исследование проводилось на суперкомпьютере "Ломоносов"<ref name="Lom">Воеводин Вл., Жуматий С., Соболев С., Антонов А., Брызгалов П., Никитенко Д., Стефанов К., Воеводин Вад. Практика суперкомпьютера «Ломоносов» // Открытые системы, 2012, N 7, С. 36-39.</ref> [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета].

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

* число процессоров [1 : 120];
* размер входных данных [1 : 15 000] векторов размерности 4.
При количестве кластеров 100.

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

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

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

[[file: Эффективность.jpg |thumb|center|700px|Изменение эффективности.]]

[http://pastebin.com/LDPNY5Ua Параллельная реализация на языке С с использованием Open MP]

== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Можно найти следующие реализации алгоритма
* Для MATLAB http://www.mathworks.com/help/fuzzy/fcm.html
* В PostgreSQL http://num-meth.srcc.msu.ru/zhurnal/tom_2012/v13r207.html
Так же готовые реализации алгоритма и его описание можно найти на сайтах
* https://habrahabr.ru/post/208496/
* http://pythonhosted.org/scikit-fuzzy/auto_examples/plot_cmeans.html
* http://www.codeproject.com/Articles/91675/Computer-Vision-Applications-with-C-Fuzzy-C-means
* https://github.com/gyaikhom/fcm

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

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

2016-11-18T22:53:28Z

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

{{algorithm
| name = Нечеткий алгоритм C средних
| serial_complexity = <math>O(C*C*K*I)</math>., где <math>I</math> - количество итераций
| input_data = <math>K*N</math>, [количество векторов * размерность]
| output_data = <math>C*K</math>, [элементы матрицы принадлежности]
| pf_height = <math>3I</math>
| pf_width = <math>C*C*K</math>
}}

Авторы : [[Участник:Protsenko|Мария Проценко]] (1.5-1.8, 2.7), [[Участник:ADovganich|Андрей Довганич]] (1.1-1.4, 1.9, 1.10)

= Свойства и структура алгоритмов =
== Общее описание алгоритма ==
Нечеткий алгоритм C-средних (fuzzy C-means) позволяет разбить имеющееся множество векторов (точек) мощностью <math>K</math> на заданное число нечетких множеств. Предназначен для кластеризации больших наборов данных. Основным достоинством алгоритма является нечеткость при определении объекта в кластер. Благодаря этому становится возможным определить объекты, которые находятся на границе, в кластеры. Из основного достоинства следует и главный недостаток - неопределенность с объектами, удаленными от центров всех кластеров. В остальном ему присущи стандартные проблемы подобного класса алгоритмов: вычислительная сложность, необходимость задания количества кластеров<ref>Нейский И.М. Классификация и сравнение методов кластеризации</ref>.

Алгоритм был разработан J.C. Dunn в 1973 г.<ref> Dunn, J. C. (1973-01-01). "A Fuzzy Relative of the ISODATA Process and Its Use in Detecting Compact Well-Separated Clusters". Journal of Cybernetics. 3 (3): 32–57. doi:10.1080/01969727308546046. ISSN 0022-0280.</ref>, усовершенствован J.C. Bezdek в 1981 г.<ref> Bezdek, James C. (1981). Pattern Recognition with Fuzzy Objective Function Algorithms. ISBN 0-306-40671-3.</ref>.

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

В общем виде алгоритм можно записать следующим образом:

# Инициализировать матрицу принадлежности;
# Вычислить центры кластеров;
# Вычислить значение решающей функции. Если значение ниже некоторого порогового или его улучшение по сравнению с предыдущей итерацией меньше определенной величины, то остановить вычисления;
# Иначе вычислить новые значения матрицы принадлежности;
# Перейти к шагу 2

== Математическое описание алгоритма ==
Рассмотрим матрицу <math> M = m_{ik} \in[0,1],\; i = 1, ..., c, \; k = 1, ..., K </math>. <math>m_{i,k}</math> - вероятность принадлежности объекта <math>k</math> к кластеру <math>i</math>; <math>c</math> - количество кластеров, <math>K</math> - количество векторов. При этом элементы матрицы удовлетворяют следующим условиям:

* сумма элементов в каждом столбце равна <math>1</math>;

* сумма всех элементов матрицы равно <math>K</math>;

Назовем <math> M </math> матрицей принадлежности.

Пусть <math>c_{i} (i = 1,2,...c)</math> - центры кластеров. Тогда рассмотрим функцию

<math>
\begin{align}
J(M, c_{1}, c_{2},...c_{c}) = \sum_{i = 1}^{c}{J_{i}} = \sum_{i = 1}^{c}\sum_{k = 1}^{K}{m_{ik}^q}d_{ik}^2 ~(1)
\end{align}
</math>

где <math> d_{ik} = \left\Vert{u_{k}-c_{i}}\right\| </math> - Евклидово расстояние между центром кластера и объектом, <math> 1 \le q \le \infty </math> - экспоненциальный весовой коэффициент, характеризующий нечеткость. Будем минимизировать значение функции <math> J </math>. Для этого вычислим центры кластеров по формуле <math> ~(2) </math>.

<math>c_{i} = {{\sum_{k = 1}^{K}{m_{ik}^q} * u_{k}} \over {\sum_{k = 1}^{K}{m_{ik}^q}}}~(2)</math>

где <math>m_{ik}</math> — коэффициент принадлежности <math>u_{k}</math> вектора к кластеру <math>c_{i}</math>

и новые значения матрицы <math> M </math> по формуле <math> ~(3) </math>

<math>m_{ik} = {1 \over \sum_{j = 1}^{c}{({{d_{ik}} \over {d_{jk}}})}^{2 \over q-1}} ~(3)</math>

<math> ~(2) </math> и <math> ~(3) </math>являются необходимым условиями достижения минимума функцией <math> J </math>. Таким образом эти два условия дают нам итерационный процесс.

Полностью алгоритм можно записать следующим образом:

# Инициализировать матрицу принадлежности <math> M </math> случайными значениями от 0 до 1;
# Вычислить центры кластеров <math>c_{i} (i = 1,2,...c)</math> используя формулу <math>~(2)</math>;
# Вычислить значение решающей функции по формуле <math>~(1)</math>. Если значение <math> J < \varepsilon,~\varepsilon > 0</math> или <math> |J_{i} - J_{i-1}| < \delta,~\delta > 0 </math>, то остановить вычисления;
# Иначе вычислить новые значения матрицы М по формуле <math>~(3)</math>;
# Перейти к шагу 2

== Вычислительное ядро алгоритма ==
Вычислительным ядром алгоритма являются формулы: <math> (1) </math>, <math> (2) </math>, <math> (3) </math>. В них производится вычисление новых центров кластеров, значения решающей функции и пересчет элементов матрицы принадлежности.

== Макроструктура алгоритма ==
Макроструктура алгоритма состоит из следующих шагов:

# Инициализация матрицы <math> M </math> случайными значениями от 0 до 1;
# Вычисление центров кластеров;
# Вычисление значения решающей функции(если оно удовлетворяет условиям останова - завершение вычислений);
# Вычисление новых элементов матрицы принадлежности;
# Переход к шагу 2;

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

Пример реализации алгоритма на языке С++. Сначала вычислим центры кластеров, потом вычислим решающую функцию, с ее помощью определим необходимость продолжать алгоритм, и при необходимости вычислим новые значения матрицы M.
<source lang="C++">

float ** m;
int *c;
int number_clusters, number_items;
m = gen_random_clusters();//заполним матрицу m случайными значениями от 0 до 1

while (true)
{
//вычисление центров кластеров
for (int i=0; i<number_clusters; i++)
{
numerator==denumerator=0;
for (int k=0; k<number_items; k++)
{
numerator+=pow(m[i, k], q)*u[k];//u[k]-вектор
denumerator+=pow(m[i, k], q);
}
c[i]= numerator / denumerator;//центры кластеров
}

j=0;//вычисление решающей функции
for (int i=0; i<number_clusters; i++)
for (int k=0; k<number_items; k++)
j+=pow(m[i, k], q)*pow(dist(c[i], x[k],2);//dist-вычисляет расстояние между заданными векторами

if ((abs(j-last_j)<delta) || (j<eps)) break;//проверка на необходимость завернешения алгоритма
last_j=j;
//обновление матрицы m
for (int i=0; i<number_clusters; i++)
for (int k=0; k<number_items; k++)
{
m[i,k]=0
for(int j=0; j<number_clusters; j++)
m[i,k]+=pow(dist(c[i], x[k])/dist(c[j], x[k]),2/(q-1));
m[i,k]=1/m[i,k];
}

}
</source>

== Последовательная сложность алгоритма ==
Каждая итерация включает в себя
* Вычисление центров кластеров <math>O(C*K)</math>
* Вычисление решающей функции <math>O(C*K)</math>
* Обновлене матрицы <math>M</math> <math>O(C*C*K)</math>
Общая сложность каждой итерации <math>O(C*C*K)</math>.

Сложность всего алгоритма будет зависеть от числа итераций, которое зависит от
* Выбора начального приближения
* Выбора условий останова

Окончательно, сложность алгоритма будет равна произведению количества итераций на их сложность

== Информационный граф ==
'''Первый ярус''' состоит из <math>C</math> параллельных операций, каждая их которых в свою очередь состоит из <math>K</math> параллельных операций, и одной, которая выполняется с использованием результата предыдущих.
Результатом работы этого яруса являются значения центров кластеров , которые будут использоваться на следующем ярусе.

'''Второй ярус''' содержит в себе <math>C*K</math> параллельных операций.
Результатом его работы является значение решающей функции <math>J</math>. Её значение определяет необходимость завершения алгоритма.

'''Третий ярус''' включает <math>C*K</math> параллельных операций, каждая из которых состоит из <math>C</math> параллельных операций, и одной, которая выполняется с использованием результата предыдущих.

[[Файл:Суперпрак.png|1200px|thumb|center|Информационный граф алгоритма. Салатовым цветом обозначены вершины графа-операции. Дугами обозначена передача информации, передаваемые данные надписаны сверху.]]

== Ресурс параллелизма алгоритма ==
На каждом шаге алгоритма необходимо вычислять сумму элементов массивов. Сложность ее вычисления на первом шаге (вычисление центров кластеров) при параллельной реализации составляет <math>O(\log_{2} C)</math>. Для каждого элемента из набора входных данных(<math> K </math>), но здесь возможен независимый расчет(координатный параллелизм). На втором шаге(вычисление решающей функции) сложность будет <math>O(\log_{2} {C*K})</math>, потому что здесь необходимо сложение всех элементов. На третьем шаге имеем сложность <math>O(\log_{2} C^2)</math>. Итого суммарная сложность итерации: <math>O(\log_{2} {C*K} + \log_{2} C^3)</math>. Воспользовавшись свойствами логарифма произведения получаем: <math>O(\log_{2} {K} + \log_{2} C^4)</math>.

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

== Входные и выходные данные алгоритма ==
Входные данные:
* <math>u_{k} ~k = 1, ..., K</math> - набор входных векторов размерности <math> N </math>;
* <math>C</math> - количество кластеров;
* <math>q</math> - экспоненциальный весовой коэффициент, характеризующий нечеткость;
* <math>\varepsilon > 0, ~\delta > 0</math> - коэффициенты, описывающие точность алгоритма.
Объем входных данных: <math> K*N </math>

Выходные данные:
* <math> M </math> - матрица принадлежности.
Объем выходных данных: <math> C*K </math>

== Свойства алгоритма ==
*Соотношение последовательной и параллельной сложности алгоритма: <math>C*C*K \over {\log_{2} {K} + \log_{2} C^4}</math>. Соответственно при распараллеливании наибольший прирост в производительности мы получим при разбиении большого набора данных на большее число кластеров;
*Вычислительная мощность: <math>{{C^2*K} \over {C*K}} = C</math>. Получается, что на чем большее количество кластеров мы разбиваем набор данных, тем менее затратным становится перемещение данных;
*Алгоритм не является устойчивым, как и другие подобные алгоритмы этого класса(например k-means). Очень многое зависит как от входных данных, так и от изначальных параметров приближения(заполнения матрицы принадлежности => исходных центров кластеров);
*Не является детерминированным. Так же очень многое зависит как от входных данных, так и от изначальных параметров приближения(заполнения матрицы принадлежности => исходных центров кластеров);
*Алгоритм не сбалансирован - доминирует операция умножения. Параллельные ветви алгоритма сбалансированы;
*Степень исхода вершины информационного графа - 2.

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

Проведём исследование масштабируемости параллельной реализации разложения Холецкого согласно [[Scalability methodology|методике]]. Исследование проводилось на суперкомпьютере "Ломоносов"<ref name="Lom">Воеводин Вл., Жуматий С., Соболев С., Антонов А., Брызгалов П., Никитенко Д., Стефанов К., Воеводин Вад. Практика суперкомпьютера «Ломоносов» // Открытые системы, 2012, N 7, С. 36-39.</ref> [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета].

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

* число процессоров [1 : 120];
* размер входных данных [1 : 15 000] векторов размерности 4.
При количестве кластеров 100.

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

[[file: Эффективность.jpg |thumb|center|700px|Изменение эффективности.]]

[http://pastebin.com/LDPNY5Ua Параллельная реализация на языке С с использованием Open MP]

== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Можно найти следующие реализации алгоритма
* Для MATLAB http://www.mathworks.com/help/fuzzy/fcm.html
* В PostgreSQL http://num-meth.srcc.msu.ru/zhurnal/tom_2012/v13r207.html
Так же готовые реализации алгоритма и его описание можно найти на сайтах
* https://habrahabr.ru/post/208496/
* http://pythonhosted.org/scikit-fuzzy/auto_examples/plot_cmeans.html
* http://www.codeproject.com/Articles/91675/Computer-Vision-Applications-with-C-Fuzzy-C-means
* https://github.com/gyaikhom/fcm

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

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

2016-11-18T21:19:14Z

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

{{algorithm
| name = Нечеткий алгоритм C средних
| serial_complexity = <math>O(C*C*K*I)</math>., где <math>I</math> - количество итераций
| input_data = <math>K*N</math>, [количество векторов * размерность]
| output_data = <math>C*K</math>, [элементы матрицы принадлежности]
| pf_height = <math>3I</math>
| pf_width = <math>C*C*K</math>
}}

Авторы : [[Участник:Protsenko|Мария Проценко]] (1.5-1.8, 2.7), [[Участник:ADovganich|Андрей Довганич]] (1.1-1.4, 1.9, 1.10)

= Свойства и структура алгоритмов =
== Общее описание алгоритма ==
Нечеткий алгоритм C-средних (fuzzy C-means) позволяет разбить имеющееся множество векторов (точек) мощностью <math>K</math> на заданное число нечетких множеств. Предназначен для кластеризации больших наборов данных. Основным достоинством алгоритма является нечеткость при определении объекта в кластер. Благодаря этому становится возможным определить объекты, которые находятся на границе, в кластеры. Из основного достоинства следует и главный недостаток - неопределенность с объектами, удаленными от центров всех кластеров. В остальном ему присущи стандартные проблемы подобного класса алгоритмов: вычислительная сложность, необходимость задания количества кластеров<ref>Нейский И.М. Классификация и сравнение методов кластеризации</ref>.

Алгоритм был разработан J.C. Dunn в 1973 г.<ref> Dunn, J. C. (1973-01-01). "A Fuzzy Relative of the ISODATA Process and Its Use in Detecting Compact Well-Separated Clusters". Journal of Cybernetics. 3 (3): 32–57. doi:10.1080/01969727308546046. ISSN 0022-0280.</ref>, усовершенствован J.C. Bezdek в 1981 г.<ref> Bezdek, James C. (1981). Pattern Recognition with Fuzzy Objective Function Algorithms. ISBN 0-306-40671-3.</ref>.

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

В общем виде алгоритм можно записать следующим образом:

# Инициализировать матрицу принадлежности;
# Вычислить центры кластеров;
# Вычислить значение решающей функции. Если значение ниже некоторого порогового или его улучшение по сравнению с предыдущей итерацией меньше определенной величины, то остановить вычисления;
# Иначе вычислить новые значения матрицы принадлежности;
# Перейти к шагу 2

== Математическое описание алгоритма ==
Рассмотрим матрицу <math> M = m_{ik} \in[0,1],\; i = 1, ..., c, \; k = 1, ..., K </math>. <math>m_{i,k}</math> - вероятность принадлежности объекта <math>k</math> к кластеру <math>i</math>; <math>c</math> - количество кластеров, <math>K</math> - количество векторов. При этом элементы матрицы удовлетворяют следующим условиям:

* сумма элементов в каждом столбце равна <math>1</math>;

* сумма всех элементов матрицы равно <math>K</math>;

Назовем <math> M </math> матрицей принадлежности.

Пусть <math>c_{i} (i = 1,2,...c)</math> - центры кластеров. Тогда рассмотрим функцию

<math>
\begin{align}
J(M, c_{1}, c_{2},...c_{c}) = \sum_{i = 1}^{c}{J_{i}} = \sum_{i = 1}^{c}\sum_{k = 1}^{K}{m_{ik}^q}d_{ik}^2 ~(1)
\end{align}
</math>

где <math> d_{ik} = \left\Vert{u_{k}-c_{i}}\right\| </math> - Евклидово расстояние между центром кластера и объектом, <math> 1 \le q \le \infty </math> - экспоненциальный весовой коэффициент, характеризующий нечеткость. Будем минимизировать значение функции <math> J </math>. Для этого вычислим центры кластеров по формуле <math> ~(2) </math>.

<math>c_{i} = {{\sum_{k = 1}^{K}{m_{ik}^q} * u_{k}} \over {\sum_{k = 1}^{K}{m_{ik}^q}}}~(2)</math>

где <math>m_{ik}</math> — коэффициент принадлежности <math>u_{k}</math> вектора к кластеру <math>c_{i}</math>

и новые значения матрицы <math> M </math> по формуле <math> ~(3) </math>

<math>m_{ik} = {1 \over \sum_{j = 1}^{c}{({{d_{ik}} \over {d_{jk}}})}^{2 \over q-1}} ~(3)</math>

<math> ~(2) </math> и <math> ~(3) </math>являются необходимым условиями достижения минимума функцией <math> J </math>. Таким образом эти два условия дают нам итерационный процесс.

Полностью алгоритм можно записать следующим образом:

# Инициализировать матрицу принадлежности <math> M </math> случайными значениями от 0 до 1;
# Вычислить центры кластеров <math>c_{i} (i = 1,2,...c)</math> используя формулу <math>~(2)</math>;
# Вычислить значение решающей функции по формуле <math>~(1)</math>. Если значение <math> J < \varepsilon,~\varepsilon > 0</math> или <math> |J_{i} - J_{i-1}| < \delta,~\delta > 0 </math>, то остановить вычисления;
# Иначе вычислить новые значения матрицы М по формуле <math>~(3)</math>;
# Перейти к шагу 2

== Вычислительное ядро алгоритма ==
Вычислительным ядром алгоритма являются формулы: <math> (1) </math>, <math> (2) </math>, <math> (3) </math>. В них производится вычисление новых центров кластеров, значения решающей функции и пересчет элементов матрицы принадлежности.

== Макроструктура алгоритма ==
Макроструктура алгоритма состоит из следующих шагов:

# Инициализация матрицы <math> M </math> случайными значениями от 0 до 1;
# Вычисление центров кластеров;
# Вычисление значения решающей функции(если оно удовлетворяет условиям останова - завершение вычислений);
# Вычисление новых элементов матрицы принадлежности;
# Переход к шагу 2;

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

Пример реализации алгоритма на языке С++. Сначала вычислим центры кластеров, потом вычислим решающую функцию, с ее помощью определим необходимость продолжать алгоритм, и при необходимости вычислим новые значения матрицы M.
<source lang="C++">

float ** m;
int *c;
int number_clusters, number_items;
m = gen_random_clusters();//заполним матрицу m случайными значениями от 0 до 1

while (true)
{
//вычисление центров кластеров
for (int i=0; i<number_clusters; i++)
{
numerator==denumerator=0;
for (int k=0; k<number_items; k++)
{
numerator+=pow(m[i, k], q)*u[k];//u[k]-вектор
denumerator+=pow(m[i, k], q);
}
c[i]= numerator / denumerator;//центры кластеров
}

j=0;//вычисление решающей функции
for (int i=0; i<number_clusters; i++)
for (int k=0; k<number_items; k++)
j+=pow(m[i, k], q)*pow(dist(c[i], x[k],2);//dist-вычисляет расстояние между заданными векторами

if ((abs(j-last_j)<delta) || (j<eps)) break;//проверка на необходимость завернешения алгоритма
last_j=j;
//обновление матрицы m
for (int i=0; i<number_clusters; i++)
for (int k=0; k<number_items; k++)
{
m[i,k]=0
for(int j=0; j<number_clusters; j++)
m[i,k]+=pow(dist(c[i], x[k])/dist(c[j], x[k]),2/(q-1));
m[i,k]=1/m[i,k];
}

}
</source>

== Последовательная сложность алгоритма ==
Каждая итерация включает в себя
* Вычисление центров кластеров <math>O(C*K)</math>
* Вычисление решающей функции <math>O(C*K)</math>
* Обновлене матрицы <math>M</math> <math>O(C*C*K)</math>
Общая сложность каждой итерации <math>O(C*C*K)</math>.

Сложность всего алгоритма будет зависеть от числа итераций, которое зависит от
* Выбора начального приближения
* Выбора условий останова

Окончательно, сложность алгоритма будет равна произведению количества итераций на их сложность

== Информационный граф ==
'''Первый ярус''' состоит из <math>C</math> параллельных операций, каждая их которых в свою очередь состоит из <math>K</math> параллельных операций, и одной, которая выполняется с использованием результата предыдущих.
Результатом работы этого яруса являются значения центров кластеров , которые будут использоваться на следующем ярусе.

'''Второй ярус''' содержит в себе <math>C*K</math> параллельных операций.
Результатом его работы является значение решающей функции <math>J</math>. Её значение определяет необходимость завершения алгоритма.

'''Третий ярус''' включает <math>C*K</math> параллельных операций, каждая из которых состоит из <math>C</math> параллельных операций, и одной, которая выполняется с использованием результата предыдущих.

[[Файл:Суперпрак.png|1200px|thumb|center|Информационный граф алгоритма. Салатовым цветом обозначены вершины графа-операции. Дугами обозначена передача информации, передаваемые данные надписаны сверху.]]

== Ресурс параллелизма алгоритма ==
На каждом шаге алгоритма необходимо вычислять сумму элементов массивов. Сложность ее вычисления на первом шаге (вычисление центров кластеров) при параллельной реализации составляет <math>O(\log_{2} C)</math>. Для каждого элемента из набора входных данных(<math> K </math>), но здесь возможен независимый расчет(координатный параллелизм). На втором шаге(вычисление решающей функции) сложность будет <math>O(\log_{2} {C*K})</math>, потому что здесь необходимо сложение всех элементов. На третьем шаге имеем сложность <math>O(\log_{2} C^2)</math>. Итого суммарная сложность итерации: <math>O(\log_{2} {C*K} + \log_{2} C^3)</math>. Воспользовавшись свойствами логарифма произведения получаем: <math>O(\log_{2} {K} + \log_{2} C^4)</math>.

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

== Входные и выходные данные алгоритма ==
Входные данные:
* <math>u_{k} ~k = 1, ..., K</math> - набор входных векторов размерности <math> N </math>;
* <math>C</math> - количество кластеров;
* <math>q</math> - экспоненциальный весовой коэффициент, характеризующий нечеткость;
* <math>\varepsilon > 0, ~\delta > 0</math> - коэффициенты, описывающие точность алгоритма.
Объем входных данных: <math> K*N </math>

Выходные данные:
* <math> M </math> - матрица принадлежности.
Объем выходных данных: <math> C*K </math>

== Свойства алгоритма ==
*Соотношение последовательной и параллельной сложности алгоритма: <math>C*C*K \over {\log_{2} {K} + \log_{2} C^4}</math>. Соответственно при распараллеливании наибольший прирост в производительности мы получим при разбиении большого набора данных на большее число кластеров;
*Вычислительная мощность: <math>{{C^2*K} \over {C*K}} = C</math>. Получается, что на чем большее количество кластеров мы разбиваем набор данных, тем менее затратным становится перемещение данных;
*Алгоритм не является устойчивым, как и другие подобные алгоритмы этого класса(например k-means). Очень многое зависит как от входных данных, так и от изначальных параметров приближения(заполнения матрицы принадлежности => исходных центров кластеров);
*Не является детерминированным. Так же очень многое зависит как от входных данных, так и от изначальных параметров приближения(заполнения матрицы принадлежности => исходных центров кластеров);
*Алгоритм не сбалансирован - доминирует операция умножения. Параллельные ветви алгоритма сбалансированы;
*Степень исхода вершины информационного графа - 2.

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

Проведём исследование масштабируемости параллельной реализации разложения Холецкого согласно [[Scalability methodology|методике]]. Исследование проводилось на суперкомпьютере "Ломоносов"<ref name="Lom">Воеводин Вл., Жуматий С., Соболев С., Антонов А., Брызгалов П., Никитенко Д., Стефанов К., Воеводин Вад. Практика суперкомпьютера «Ломоносов» // Открытые системы, 2012, N 7, С. 36-39.</ref> [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета].

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

* число процессоров [1 : 120];
* размер входных данных [1 : 15 000] векторов размерности 4.
При количестве кластеров 100.

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

[[file: Эффективность.jpg |thumb|center|700px|Изменение эффективности.]]

== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Можно найти следующие реализации алгоритма
* Для MATLAB http://www.mathworks.com/help/fuzzy/fcm.html
* В PostgreSQL http://num-meth.srcc.msu.ru/zhurnal/tom_2012/v13r207.html
Так же готовые реализации алгоритма и его описание можно найти на сайтах
* https://habrahabr.ru/post/208496/
* http://pythonhosted.org/scikit-fuzzy/auto_examples/plot_cmeans.html
* http://www.codeproject.com/Articles/91675/Computer-Vision-Applications-with-C-Fuzzy-C-means
* https://github.com/gyaikhom/fcm

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

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

2016-11-18T21:07:28Z

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

{{algorithm
| name = Нечеткий алгоритм C средних
| serial_complexity = <math>O(C*C*K*I)</math>., где <math>I</math> - количество итераций
| input_data = <math>K*N</math>, [количество векторов * размерность]
| output_data = <math>C*K</math>, [элементы матрицы принадлежности]
| pf_height = <math>3I</math>
| pf_width = <math>C*C*K</math>
}}

Авторы : [[Участник:Protsenko|Мария Проценко]] (1.5-1.8, 2.7), [[Участник:ADovganich|Андрей Довганич]] (1.1-1.4, 1.9, 1.10)

= Свойства и структура алгоритмов =
== Общее описание алгоритма ==
Нечеткий алгоритм C-средних (fuzzy C-means) позволяет разбить имеющееся множество векторов (точек) мощностью <math>K</math> на заданное число нечетких множеств. Предназначен для кластеризации больших наборов данных. Основным достоинством алгоритма является нечеткость при определении объекта в кластер. Благодаря этому становится возможным определить объекты, которые находятся на границе, в кластеры. Из основного достоинства следует и главный недостаток - неопределенность с объектами, удаленными от центров всех кластеров. В остальном ему присущи стандартные проблемы подобного класса алгоритмов: вычислительная сложность, необходимость задания количества кластеров<ref>Нейский И.М. Классификация и сравнение методов кластеризации</ref>.

Алгоритм был разработан J.C. Dunn в 1973 г.<ref> Dunn, J. C. (1973-01-01). "A Fuzzy Relative of the ISODATA Process and Its Use in Detecting Compact Well-Separated Clusters". Journal of Cybernetics. 3 (3): 32–57. doi:10.1080/01969727308546046. ISSN 0022-0280.</ref>, усовершенствован J.C. Bezdek в 1981 г.<ref> Bezdek, James C. (1981). Pattern Recognition with Fuzzy Objective Function Algorithms. ISBN 0-306-40671-3.</ref>.

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

В общем виде алгоритм можно записать следующим образом:

# Инициализировать матрицу принадлежности;
# Вычислить центры кластеров;
# Вычислить значение решающей функции. Если значение ниже некоторого порогового или его улучшение по сравнению с предыдущей итерацией меньше определенной величины, то остановить вычисления;
# Иначе вычислить новые значения матрицы принадлежности;
# Перейти к шагу 2

== Математическое описание алгоритма ==
Рассмотрим матрицу <math> M = m_{ik} \in[0,1],\; i = 1, ..., c, \; k = 1, ..., K </math>. <math>m_{i,k}</math> - вероятность принадлежности объекта <math>k</math> к кластеру <math>i</math>; <math>c</math> - количество кластеров, <math>K</math> - количество векторов. При этом элементы матрицы удовлетворяют следующим условиям:

* сумма элементов в каждом столбце равна <math>1</math>;

* сумма всех элементов матрицы равно <math>K</math>;

Назовем <math> M </math> матрицей принадлежности.

Пусть <math>c_{i} (i = 1,2,...c)</math> - центры кластеров. Тогда рассмотрим функцию

<math>
\begin{align}
J(M, c_{1}, c_{2},...c_{c}) = \sum_{i = 1}^{c}{J_{i}} = \sum_{i = 1}^{c}\sum_{k = 1}^{K}{m_{ik}^q}d_{ik}^2 ~(1)
\end{align}
</math>

где <math> d_{ik} = \left\Vert{u_{k}-c_{i}}\right\| </math> - Евклидово расстояние между центром кластера и объектом, <math> 1 \le q \le \infty </math> - экспоненциальный весовой коэффициент, характеризующий нечеткость. Будем минимизировать значение функции <math> J </math>. Для этого вычислим центры кластеров по формуле <math> ~(2) </math>.

<math>c_{i} = {{\sum_{k = 1}^{K}{m_{ik}^q} * u_{k}} \over {\sum_{k = 1}^{K}{m_{ik}^q}}}~(2)</math>

где <math>m_{ik}</math> — коэффициент принадлежности <math>u_{k}</math> вектора к кластеру <math>c_{i}</math>

и новые значения матрицы <math> M </math> по формуле <math> ~(3) </math>

<math>m_{ik} = {1 \over \sum_{j = 1}^{c}{({{d_{ik}} \over {d_{jk}}})}^{2 \over q-1}} ~(3)</math>

<math> ~(2) </math> и <math> ~(3) </math>являются необходимым условиями достижения минимума функцией <math> J </math>. Таким образом эти два условия дают нам итерационный процесс.

Полностью алгоритм можно записать следующим образом:

# Инициализировать матрицу принадлежности <math> M </math> случайными значениями от 0 до 1;
# Вычислить центры кластеров <math>c_{i} (i = 1,2,...c)</math> используя формулу <math>~(2)</math>;
# Вычислить значение решающей функции по формуле <math>~(1)</math>. Если значение <math> J < \varepsilon,~\varepsilon > 0</math> или <math> |J_{i} - J_{i-1}| < \delta,~\delta > 0 </math>, то остановить вычисления;
# Иначе вычислить новые значения матрицы М по формуле <math>~(3)</math>;
# Перейти к шагу 2

== Вычислительное ядро алгоритма ==
Вычислительным ядром алгоритма являются формулы: <math> (1) </math>, <math> (2) </math>, <math> (3) </math>. В них производится вычисление новых центров кластеров, значения решающей функции и пересчет элементов матрицы принадлежности.

== Макроструктура алгоритма ==
Макроструктура алгоритма состоит из следующих шагов:

# Инициализация матрицы <math> M </math> случайными значениями от 0 до 1;
# Вычисление центров кластеров;
# Вычисление значения решающей функции(если оно удовлетворяет условиям останова - завершение вычислений);
# Вычисление новых элементов матрицы принадлежности;
# Переход к шагу 2;

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

Пример реализации алгоритма на языке С++. Сначала вычислим центры кластеров, потом вычислим решающую функцию, с ее помощью определим необходимость продолжать алгоритм, и при необходимости вычислим новые значения матрицы M.
<source lang="C++">

float ** m;
int *c;
int number_clusters, number_items;
m = gen_random_clusters();//заполним матрицу m случайными значениями от 0 до 1

while (true)
{
//вычисление центров кластеров
for (int i=0; i<number_clusters; i++)
{
numerator==denumerator=0;
for (int k=0; k<number_items; k++)
{
numerator+=pow(m[i, k], q)*u[k];//u[k]-вектор
denumerator+=pow(m[i, k], q);
}
c[i]= numerator / denumerator;//центры кластеров
}

j=0;//вычисление решающей функции
for (int i=0; i<number_clusters; i++)
for (int k=0; k<number_items; k++)
j+=pow(m[i, k], q)*pow(dist(c[i], x[k],2);//dist-вычисляет расстояние между заданными векторами

if ((abs(j-last_j)<delta) || (j<eps)) break;//проверка на необходимость завернешения алгоритма
last_j=j;
//обновление матрицы m
for (int i=0; i<number_clusters; i++)
for (int k=0; k<number_items; k++)
{
m[i,k]=0
for(int j=0; j<number_clusters; j++)
m[i,k]+=pow(dist(c[i], x[k])/dist(c[j], x[k]),2/(q-1));
m[i,k]=1/m[i,k];
}

}
</source>

== Последовательная сложность алгоритма ==
Каждая итерация включает в себя
* Вычисление центров кластеров <math>O(C*K)</math>
* Вычисление решающей функции <math>O(C*K)</math>
* Обновлене матрицы <math>M</math> <math>O(C*C*K)</math>
Общая сложность каждой итерации <math>O(C*C*K)</math>.

Сложность всего алгоритма будет зависеть от числа итераций, которое зависит от
* Выбора начального приближения
* Выбора условий останова

Окончательно, сложность алгоритма будет равна произведению количества итераций на их сложность

== Информационный граф ==
'''Первый ярус''' состоит из <math>C</math> параллельных операций, каждая их которых в свою очередь состоит из <math>K</math> параллельных операций, и одной, которая выполняется с использованием результата предыдущих.
Результатом работы этого яруса являются значения центров кластеров , которые будут использоваться на следующем ярусе.

'''Второй ярус''' содержит в себе <math>C*K</math> параллельных операций.
Результатом его работы является значение решающей функции <math>J</math>. Её значение определяет необходимость завершения алгоритма.

'''Третий ярус''' включает <math>C*K</math> параллельных операций, каждая из которых состоит из <math>C</math> параллельных операций, и одной, которая выполняется с использованием результата предыдущих.

[[Файл:Суперпрак.png|1200px|thumb|center|Информационный граф алгоритма. Салатовым цветом обозначены вершины графа-операции. Дугами обозначена передача информации, передаваемые данные надписаны сверху.]]

== Ресурс параллелизма алгоритма ==
На каждом шаге алгоритма необходимо вычислять сумму элементов массивов. Сложность ее вычисления на первом шаге (вычисление центров кластеров) при параллельной реализации составляет <math>O(\log_{2} C)</math>. Для каждого элемента из набора входных данных(<math> K </math>), но здесь возможен независимый расчет(координатный параллелизм). На втором шаге(вычисление решающей функции) сложность будет <math>O(\log_{2} {C*K})</math>, потому что здесь необходимо сложение всех элементов. На третьем шаге имеем сложность <math>O(\log_{2} C^2)</math>. Итого суммарная сложность итерации: <math>O(\log_{2} {C*K} + \log_{2} C^3)</math>. Воспользовавшись свойствами логарифма произведения получаем: <math>O(\log_{2} {K} + \log_{2} C^4)</math>.

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

== Входные и выходные данные алгоритма ==
Входные данные:
* <math>u_{k} ~k = 1, ..., K</math> - набор входных векторов размерности <math> N </math>;
* <math>C</math> - количество кластеров;
* <math>q</math> - экспоненциальный весовой коэффициент, характеризующий нечеткость;
* <math>\varepsilon > 0, ~\delta > 0</math> - коэффициенты, описывающие точность алгоритма.
Объем входных данных: <math> K*N </math>

Выходные данные:
* <math> M </math> - матрица принадлежности.
Объем выходных данных: <math> C*K </math>

== Свойства алгоритма ==
*Соотношение последовательной и параллельной сложности алгоритма: <math>C*C*K \over {\log_{2} {K} + \log_{2} C^4}</math>. Соответственно при распараллеливании наибольший прирост в производительности мы получим при разбиении большого набора данных на большее число кластеров;
*Вычислительная мощность: <math>{{C^2*K} \over {C*K}} = C</math>. Получается, что на чем большее количество кластеров мы разбиваем набор данных, тем менее затратным становится перемещение данных;
*Алгоритм не является устойчивым, как и другие подобные алгоритмы этого класса(например k-means). Очень многое зависит как от входных данных, так и от изначальных параметров приближения(заполнения матрицы принадлежности => исходных центров кластеров);
*Не является детерминированным. Так же очень многое зависит как от входных данных, так и от изначальных параметров приближения(заполнения матрицы принадлежности => исходных центров кластеров);
*Алгоритм не сбалансирован - доминирует операция умножения. Параллельные ветви алгоритма сбалансированы;
*Степень исхода вершины информационного графа - 2.

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

Проведём исследование масштабируемости параллельной реализации разложения Холецкого согласно [[Scalability methodology|методике]]. Исследование проводилось на суперкомпьютере "Ломоносов"<ref name="Lom">Воеводин Вл., Жуматий С., Соболев С., Антонов А., Брызгалов П., Никитенко Д., Стефанов К., Воеводин Вад. Практика суперкомпьютера «Ломоносов» // Открытые системы, 2012, N 7, С. 36-39.</ref> [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета].

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

* число процессоров [1 : 120];
* размер входных данных [1 : 15 000] векторов размерности 4.
При количестве кластеров 100.

[[file: Эффективность.jpg |thumb|center|700px|Изменение эффективности.]]

== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Можно найти следующие реализации алгоритма
* Для MATLAB http://www.mathworks.com/help/fuzzy/fcm.html
* В PostgreSQL http://num-meth.srcc.msu.ru/zhurnal/tom_2012/v13r207.html
Так же готовые реализации алгоритма и его описание можно найти на сайтах
* https://habrahabr.ru/post/208496/
* http://pythonhosted.org/scikit-fuzzy/auto_examples/plot_cmeans.html
* http://www.codeproject.com/Articles/91675/Computer-Vision-Applications-with-C-Fuzzy-C-means
* https://github.com/gyaikhom/fcm

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

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

2016-11-18T20:57:54Z

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

{{algorithm
| name = Нечеткий алгоритм C средних
| serial_complexity = <math>O(C*C*K*I)</math>., где <math>I</math> - количество итераций
| input_data = <math>K*N</math>, [количество векторов * размерность]
| output_data = <math>C*K</math>, [элементы матрицы принадлежности]
| pf_height = <math>3I</math>
| pf_width = <math>C*C*K</math>
}}

Авторы : [[Участник:Protsenko|Мария Проценко]] (1.5-1.8, 2.7), [[Участник:ADovganich|Андрей Довганич]] (1.1-1.4, 1.9, 1.10)

= Свойства и структура алгоритмов =
== Общее описание алгоритма ==
Нечеткий алгоритм C-средних (fuzzy C-means) позволяет разбить имеющееся множество векторов (точек) мощностью <math>K</math> на заданное число нечетких множеств. Предназначен для кластеризации больших наборов данных. Основным достоинством алгоритма является нечеткость при определении объекта в кластер. Благодаря этому становится возможным определить объекты, которые находятся на границе, в кластеры. Из основного достоинства следует и главный недостаток - неопределенность с объектами, удаленными от центров всех кластеров. В остальном ему присущи стандартные проблемы подобного класса алгоритмов: вычислительная сложность, необходимость задания количества кластеров<ref>Нейский И.М. Классификация и сравнение методов кластеризации</ref>.

Алгоритм был разработан J.C. Dunn в 1973 г.<ref> Dunn, J. C. (1973-01-01). "A Fuzzy Relative of the ISODATA Process and Its Use in Detecting Compact Well-Separated Clusters". Journal of Cybernetics. 3 (3): 32–57. doi:10.1080/01969727308546046. ISSN 0022-0280.</ref>, усовершенствован J.C. Bezdek в 1981 г.<ref> Bezdek, James C. (1981). Pattern Recognition with Fuzzy Objective Function Algorithms. ISBN 0-306-40671-3.</ref>.

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

В общем виде алгоритм можно записать следующим образом:

# Инициализировать матрицу принадлежности;
# Вычислить центры кластеров;
# Вычислить значение решающей функции. Если значение ниже некоторого порогового или его улучшение по сравнению с предыдущей итерацией меньше определенной величины, то остановить вычисления;
# Иначе вычислить новые значения матрицы принадлежности;
# Перейти к шагу 2

== Математическое описание алгоритма ==
Рассмотрим матрицу <math> M = m_{ik} \in[0,1],\; i = 1, ..., c, \; k = 1, ..., K </math>. <math>m_{i,k}</math> - вероятность принадлежности объекта <math>k</math> к кластеру <math>i</math>; <math>c</math> - количество кластеров, <math>K</math> - количество векторов. При этом элементы матрицы удовлетворяют следующим условиям:

* сумма элементов в каждом столбце равна <math>1</math>;

* сумма всех элементов матрицы равно <math>K</math>;

Назовем <math> M </math> матрицей принадлежности.

Пусть <math>c_{i} (i = 1,2,...c)</math> - центры кластеров. Тогда рассмотрим функцию

<math>
\begin{align}
J(M, c_{1}, c_{2},...c_{c}) = \sum_{i = 1}^{c}{J_{i}} = \sum_{i = 1}^{c}\sum_{k = 1}^{K}{m_{ik}^q}d_{ik}^2 ~(1)
\end{align}
</math>

где <math> d_{ik} = \left\Vert{u_{k}-c_{i}}\right\| </math> - Евклидово расстояние между центром кластера и объектом, <math> 1 \le q \le \infty </math> - экспоненциальный весовой коэффициент, характеризующий нечеткость. Будем минимизировать значение функции <math> J </math>. Для этого вычислим центры кластеров по формуле <math> ~(2) </math>.

<math>c_{i} = {{\sum_{k = 1}^{K}{m_{ik}^q} * u_{k}} \over {\sum_{k = 1}^{K}{m_{ik}^q}}}~(2)</math>

где <math>m_{ik}</math> — коэффициент принадлежности <math>u_{k}</math> вектора к кластеру <math>c_{i}</math>

и новые значения матрицы <math> M </math> по формуле <math> ~(3) </math>

<math>m_{ik} = {1 \over \sum_{j = 1}^{c}{({{d_{ik}} \over {d_{jk}}})}^{2 \over q-1}} ~(3)</math>

<math> ~(2) </math> и <math> ~(3) </math>являются необходимым условиями достижения минимума функцией <math> J </math>. Таким образом эти два условия дают нам итерационный процесс.

Полностью алгоритм можно записать следующим образом:

# Инициализировать матрицу принадлежности <math> M </math> случайными значениями от 0 до 1;
# Вычислить центры кластеров <math>c_{i} (i = 1,2,...c)</math> используя формулу <math>~(2)</math>;
# Вычислить значение решающей функции по формуле <math>~(1)</math>. Если значение <math> J < \varepsilon,~\varepsilon > 0</math> или <math> |J_{i} - J_{i-1}| < \delta,~\delta > 0 </math>, то остановить вычисления;
# Иначе вычислить новые значения матрицы М по формуле <math>~(3)</math>;
# Перейти к шагу 2

== Вычислительное ядро алгоритма ==
Вычислительным ядром алгоритма являются формулы: <math> (1) </math>, <math> (2) </math>, <math> (3) </math>. В них производится вычисление новых центров кластеров, значения решающей функции и пересчет элементов матрицы принадлежности.

== Макроструктура алгоритма ==
Макроструктура алгоритма состоит из следующих шагов:

# Инициализация матрицы <math> M </math> случайными значениями от 0 до 1;
# Вычисление центров кластеров;
# Вычисление значения решающей функции(если оно удовлетворяет условиям останова - завершение вычислений);
# Вычисление новых элементов матрицы принадлежности;
# Переход к шагу 2;

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

Пример реализации алгоритма на языке С++. Сначала вычислим центры кластеров, потом вычислим решающую функцию, с ее помощью определим необходимость продолжать алгоритм, и при необходимости вычислим новые значения матрицы M.
<source lang="C++">

float ** m;
int *c;
int number_clusters, number_items;
m = gen_random_clusters();//заполним матрицу m случайными значениями от 0 до 1

while (true)
{
//вычисление центров кластеров
for (int i=0; i<number_clusters; i++)
{
numerator==denumerator=0;
for (int k=0; k<number_items; k++)
{
numerator+=pow(m[i, k], q)*u[k];//u[k]-вектор
denumerator+=pow(m[i, k], q);
}
c[i]= numerator / denumerator;//центры кластеров
}

j=0;//вычисление решающей функции
for (int i=0; i<number_clusters; i++)
for (int k=0; k<number_items; k++)
j+=pow(m[i, k], q)*pow(dist(c[i], x[k],2);//dist-вычисляет расстояние между заданными векторами

if ((abs(j-last_j)<delta) || (j<eps)) break;//проверка на необходимость завернешения алгоритма
last_j=j;
//обновление матрицы m
for (int i=0; i<number_clusters; i++)
for (int k=0; k<number_items; k++)
{
m[i,k]=0
for(int j=0; j<number_clusters; j++)
m[i,k]+=pow(dist(c[i], x[k])/dist(c[j], x[k]),2/(q-1));
m[i,k]=1/m[i,k];
}

}
</source>

== Последовательная сложность алгоритма ==
Каждая итерация включает в себя
* Вычисление центров кластеров <math>O(C*K)</math>
* Вычисление решающей функции <math>O(C*K)</math>
* Обновлене матрицы <math>M</math> <math>O(C*C*K)</math>
Общая сложность каждой итерации <math>O(C*C*K)</math>.

Сложность всего алгоритма будет зависеть от числа итераций, которое зависит от
* Выбора начального приближения
* Выбора условий останова

Окончательно, сложность алгоритма будет равна произведению количества итераций на их сложность

== Информационный граф ==
'''Первый ярус''' состоит из <math>C</math> параллельных операций, каждая их которых в свою очередь состоит из <math>K</math> параллельных операций, и одной, которая выполняется с использованием результата предыдущих.
Результатом работы этого яруса являются значения центров кластеров , которые будут использоваться на следующем ярусе.

'''Второй ярус''' содержит в себе <math>C*K</math> параллельных операций.
Результатом его работы является значение решающей функции <math>J</math>. Её значение определяет необходимость завершения алгоритма.

'''Третий ярус''' включает <math>C*K</math> параллельных операций, каждая из которых состоит из <math>C</math> параллельных операций, и одной, которая выполняется с использованием результата предыдущих.

[[Файл:Суперпрак.png|1200px|thumb|center|Информационный граф алгоритма. Салатовым цветом обозначены вершины графа-операции. Дугами обозначена передача информации, передаваемые данные надписаны сверху.]]

== Ресурс параллелизма алгоритма ==
На каждом шаге алгоритма необходимо вычислять сумму элементов массивов. Сложность ее вычисления на первом шаге (вычисление центров кластеров) при параллельной реализации составляет <math>O(\log_{2} C)</math>. Для каждого элемента из набора входных данных(<math> K </math>), но здесь возможен независимый расчет(координатный параллелизм). На втором шаге(вычисление решающей функции) сложность будет <math>O(\log_{2} {C*K})</math>, потому что здесь необходимо сложение всех элементов. На третьем шаге имеем сложность <math>O(\log_{2} C^2)</math>. Итого суммарная сложность итерации: <math>O(\log_{2} {C*K} + \log_{2} C^3)</math>. Воспользовавшись свойствами логарифма произведения получаем: <math>O(\log_{2} {K} + \log_{2} C^4)</math>.

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

== Входные и выходные данные алгоритма ==
Входные данные:
* <math>u_{k} ~k = 1, ..., K</math> - набор входных векторов размерности <math> N </math>;
* <math>C</math> - количество кластеров;
* <math>q</math> - экспоненциальный весовой коэффициент, характеризующий нечеткость;
* <math>\varepsilon > 0, ~\delta > 0</math> - коэффициенты, описывающие точность алгоритма.
Объем входных данных: <math> K*N </math>

Выходные данные:
* <math> M </math> - матрица принадлежности.
Объем выходных данных: <math> C*K </math>

== Свойства алгоритма ==
*Соотношение последовательной и параллельной сложности алгоритма: <math>C*C*K \over {\log_{2} {K} + \log_{2} C^4}</math>. Соответственно при распараллеливании наибольший прирост в производительности мы получим при разбиении большого набора данных на большее число кластеров;
*Вычислительная мощность: <math>{{C^2*K} \over {C*K}} = C</math>. Получается, что на чем большее количество кластеров мы разбиваем набор данных, тем менее затратным становится перемещение данных;
*Алгоритм не является устойчивым, как и другие подобные алгоритмы этого класса(например k-means). Очень многое зависит как от входных данных, так и от изначальных параметров приближения(заполнения матрицы принадлежности => исходных центров кластеров);
*Не является детерминированным. Так же очень многое зависит как от входных данных, так и от изначальных параметров приближения(заполнения матрицы принадлежности => исходных центров кластеров);
*Алгоритм не сбалансирован - доминирует операция умножения. Параллельные ветви алгоритма сбалансированы;
*Степень исхода вершины информационного графа - 2.

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

Проведём исследование масштабируемости параллельной реализации разложения Холецкого согласно [[Scalability methodology|методике]]. Исследование проводилось на суперкомпьютере "Ломоносов"<ref name="Lom">Воеводин Вл., Жуматий С., Соболев С., Антонов А., Брызгалов П., Никитенко Д., Стефанов К., Воеводин Вад. Практика суперкомпьютера «Ломоносов» // Открытые системы, 2012, N 7, С. 36-39.</ref> [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета].

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

* число процессоров [1 : 120];
* размер входных данных [1 : 15 000] верторок размерности 4.
При количестве кластеров 100.

[[file: Эффективность.jpg |thumb|center|700px|Изменение эффективности.]]

== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Можно найти следующие реализации алгоритма
* Для MATLAB http://www.mathworks.com/help/fuzzy/fcm.html
* В PostgreSQL http://num-meth.srcc.msu.ru/zhurnal/tom_2012/v13r207.html
Так же готовые реализации алгоритма и его описание можно найти на сайтах
* https://habrahabr.ru/post/208496/
* http://pythonhosted.org/scikit-fuzzy/auto_examples/plot_cmeans.html
* http://www.codeproject.com/Articles/91675/Computer-Vision-Applications-with-C-Fuzzy-C-means
* https://github.com/gyaikhom/fcm

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

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

2016-11-18T20:57:42Z

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

{{algorithm
| name = Нечеткий алгоритм C средних
| serial_complexity = <math>O(C*C*K*I)</math>., где <math>I</math> - количество итераций
| input_data = <math>K*N</math>, [количество векторов * размерность]
| output_data = <math>C*K</math>, [элементы матрицы принадлежности]
| pf_height = <math>3I</math>
| pf_width = <math>C*C*K</math>
}}

Авторы : [[Участник:Protsenko|Мария Проценко]] (1.5-1.8, 2.7), [[Участник:ADovganich|Андрей Довганич]] (1.1-1.4, 1.9, 1.10)

= Свойства и структура алгоритмов =
== Общее описание алгоритма ==
Нечеткий алгоритм C-средних (fuzzy C-means) позволяет разбить имеющееся множество векторов (точек) мощностью <math>K</math> на заданное число нечетких множеств. Предназначен для кластеризации больших наборов данных. Основным достоинством алгоритма является нечеткость при определении объекта в кластер. Благодаря этому становится возможным определить объекты, которые находятся на границе, в кластеры. Из основного достоинства следует и главный недостаток - неопределенность с объектами, удаленными от центров всех кластеров. В остальном ему присущи стандартные проблемы подобного класса алгоритмов: вычислительная сложность, необходимость задания количества кластеров<ref>Нейский И.М. Классификация и сравнение методов кластеризации</ref>.

Алгоритм был разработан J.C. Dunn в 1973 г.<ref> Dunn, J. C. (1973-01-01). "A Fuzzy Relative of the ISODATA Process and Its Use in Detecting Compact Well-Separated Clusters". Journal of Cybernetics. 3 (3): 32–57. doi:10.1080/01969727308546046. ISSN 0022-0280.</ref>, усовершенствован J.C. Bezdek в 1981 г.<ref> Bezdek, James C. (1981). Pattern Recognition with Fuzzy Objective Function Algorithms. ISBN 0-306-40671-3.</ref>.

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

В общем виде алгоритм можно записать следующим образом:

# Инициализировать матрицу принадлежности;
# Вычислить центры кластеров;
# Вычислить значение решающей функции. Если значение ниже некоторого порогового или его улучшение по сравнению с предыдущей итерацией меньше определенной величины, то остановить вычисления;
# Иначе вычислить новые значения матрицы принадлежности;
# Перейти к шагу 2

== Математическое описание алгоритма ==
Рассмотрим матрицу <math> M = m_{ik} \in[0,1],\; i = 1, ..., c, \; k = 1, ..., K </math>. <math>m_{i,k}</math> - вероятность принадлежности объекта <math>k</math> к кластеру <math>i</math>; <math>c</math> - количество кластеров, <math>K</math> - количество векторов. При этом элементы матрицы удовлетворяют следующим условиям:

* сумма элементов в каждом столбце равна <math>1</math>;

* сумма всех элементов матрицы равно <math>K</math>;

Назовем <math> M </math> матрицей принадлежности.

Пусть <math>c_{i} (i = 1,2,...c)</math> - центры кластеров. Тогда рассмотрим функцию

<math>
\begin{align}
J(M, c_{1}, c_{2},...c_{c}) = \sum_{i = 1}^{c}{J_{i}} = \sum_{i = 1}^{c}\sum_{k = 1}^{K}{m_{ik}^q}d_{ik}^2 ~(1)
\end{align}
</math>

где <math> d_{ik} = \left\Vert{u_{k}-c_{i}}\right\| </math> - Евклидово расстояние между центром кластера и объектом, <math> 1 \le q \le \infty </math> - экспоненциальный весовой коэффициент, характеризующий нечеткость. Будем минимизировать значение функции <math> J </math>. Для этого вычислим центры кластеров по формуле <math> ~(2) </math>.

<math>c_{i} = {{\sum_{k = 1}^{K}{m_{ik}^q} * u_{k}} \over {\sum_{k = 1}^{K}{m_{ik}^q}}}~(2)</math>

где <math>m_{ik}</math> — коэффициент принадлежности <math>u_{k}</math> вектора к кластеру <math>c_{i}</math>

и новые значения матрицы <math> M </math> по формуле <math> ~(3) </math>

<math>m_{ik} = {1 \over \sum_{j = 1}^{c}{({{d_{ik}} \over {d_{jk}}})}^{2 \over q-1}} ~(3)</math>

<math> ~(2) </math> и <math> ~(3) </math>являются необходимым условиями достижения минимума функцией <math> J </math>. Таким образом эти два условия дают нам итерационный процесс.

Полностью алгоритм можно записать следующим образом:

# Инициализировать матрицу принадлежности <math> M </math> случайными значениями от 0 до 1;
# Вычислить центры кластеров <math>c_{i} (i = 1,2,...c)</math> используя формулу <math>~(2)</math>;
# Вычислить значение решающей функции по формуле <math>~(1)</math>. Если значение <math> J < \varepsilon,~\varepsilon > 0</math> или <math> |J_{i} - J_{i-1}| < \delta,~\delta > 0 </math>, то остановить вычисления;
# Иначе вычислить новые значения матрицы М по формуле <math>~(3)</math>;
# Перейти к шагу 2

== Вычислительное ядро алгоритма ==
Вычислительным ядром алгоритма являются формулы: <math> (1) </math>, <math> (2) </math>, <math> (3) </math>. В них производится вычисление новых центров кластеров, значения решающей функции и пересчет элементов матрицы принадлежности.

== Макроструктура алгоритма ==
Макроструктура алгоритма состоит из следующих шагов:

# Инициализация матрицы <math> M </math> случайными значениями от 0 до 1;
# Вычисление центров кластеров;
# Вычисление значения решающей функции(если оно удовлетворяет условиям останова - завершение вычислений);
# Вычисление новых элементов матрицы принадлежности;
# Переход к шагу 2;

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

Пример реализации алгоритма на языке С++. Сначала вычислим центры кластеров, потом вычислим решающую функцию, с ее помощью определим необходимость продолжать алгоритм, и при необходимости вычислим новые значения матрицы M.
<source lang="C++">

float ** m;
int *c;
int number_clusters, number_items;
m = gen_random_clusters();//заполним матрицу m случайными значениями от 0 до 1

while (true)
{
//вычисление центров кластеров
for (int i=0; i<number_clusters; i++)
{
numerator==denumerator=0;
for (int k=0; k<number_items; k++)
{
numerator+=pow(m[i, k], q)*u[k];//u[k]-вектор
denumerator+=pow(m[i, k], q);
}
c[i]= numerator / denumerator;//центры кластеров
}

j=0;//вычисление решающей функции
for (int i=0; i<number_clusters; i++)
for (int k=0; k<number_items; k++)
j+=pow(m[i, k], q)*pow(dist(c[i], x[k],2);//dist-вычисляет расстояние между заданными векторами

if ((abs(j-last_j)<delta) || (j<eps)) break;//проверка на необходимость завернешения алгоритма
last_j=j;
//обновление матрицы m
for (int i=0; i<number_clusters; i++)
for (int k=0; k<number_items; k++)
{
m[i,k]=0
for(int j=0; j<number_clusters; j++)
m[i,k]+=pow(dist(c[i], x[k])/dist(c[j], x[k]),2/(q-1));
m[i,k]=1/m[i,k];
}

}
</source>

== Последовательная сложность алгоритма ==
Каждая итерация включает в себя
* Вычисление центров кластеров <math>O(C*K)</math>
* Вычисление решающей функции <math>O(C*K)</math>
* Обновлене матрицы <math>M</math> <math>O(C*C*K)</math>
Общая сложность каждой итерации <math>O(C*C*K)</math>.

Сложность всего алгоритма будет зависеть от числа итераций, которое зависит от
* Выбора начального приближения
* Выбора условий останова

Окончательно, сложность алгоритма будет равна произведению количества итераций на их сложность

== Информационный граф ==
'''Первый ярус''' состоит из <math>C</math> параллельных операций, каждая их которых в свою очередь состоит из <math>K</math> параллельных операций, и одной, которая выполняется с использованием результата предыдущих.
Результатом работы этого яруса являются значения центров кластеров , которые будут использоваться на следующем ярусе.

'''Второй ярус''' содержит в себе <math>C*K</math> параллельных операций.
Результатом его работы является значение решающей функции <math>J</math>. Её значение определяет необходимость завершения алгоритма.

'''Третий ярус''' включает <math>C*K</math> параллельных операций, каждая из которых состоит из <math>C</math> параллельных операций, и одной, которая выполняется с использованием результата предыдущих.

[[Файл:Суперпрак.png|1200px|thumb|center|Информационный граф алгоритма. Салатовым цветом обозначены вершины графа-операции. Дугами обозначена передача информации, передаваемые данные надписаны сверху.]]

== Ресурс параллелизма алгоритма ==
На каждом шаге алгоритма необходимо вычислять сумму элементов массивов. Сложность ее вычисления на первом шаге (вычисление центров кластеров) при параллельной реализации составляет <math>O(\log_{2} C)</math>. Для каждого элемента из набора входных данных(<math> K </math>), но здесь возможен независимый расчет(координатный параллелизм). На втором шаге(вычисление решающей функции) сложность будет <math>O(\log_{2} {C*K})</math>, потому что здесь необходимо сложение всех элементов. На третьем шаге имеем сложность <math>O(\log_{2} C^2)</math>. Итого суммарная сложность итерации: <math>O(\log_{2} {C*K} + \log_{2} C^3)</math>. Воспользовавшись свойствами логарифма произведения получаем: <math>O(\log_{2} {K} + \log_{2} C^4)</math>.

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

== Входные и выходные данные алгоритма ==
Входные данные:
* <math>u_{k} ~k = 1, ..., K</math> - набор входных векторов размерности <math> N </math>;
* <math>C</math> - количество кластеров;
* <math>q</math> - экспоненциальный весовой коэффициент, характеризующий нечеткость;
* <math>\varepsilon > 0, ~\delta > 0</math> - коэффициенты, описывающие точность алгоритма.
Объем входных данных: <math> K*N </math>

Выходные данные:
* <math> M </math> - матрица принадлежности.
Объем выходных данных: <math> C*K </math>

== Свойства алгоритма ==
*Соотношение последовательной и параллельной сложности алгоритма: <math>C*C*K \over {\log_{2} {K} + \log_{2} C^4}</math>. Соответственно при распараллеливании наибольший прирост в производительности мы получим при разбиении большого набора данных на большее число кластеров;
*Вычислительная мощность: <math>{{C^2*K} \over {C*K}} = C</math>. Получается, что на чем большее количество кластеров мы разбиваем набор данных, тем менее затратным становится перемещение данных;
*Алгоритм не является устойчивым, как и другие подобные алгоритмы этого класса(например k-means). Очень многое зависит как от входных данных, так и от изначальных параметров приближения(заполнения матрицы принадлежности => исходных центров кластеров);
*Не является детерминированным. Так же очень многое зависит как от входных данных, так и от изначальных параметров приближения(заполнения матрицы принадлежности => исходных центров кластеров);
*Алгоритм не сбалансирован - доминирует операция умножения. Параллельные ветви алгоритма сбалансированы;
*Степень исхода вершины информационного графа - 2.

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

Проведём исследование масштабируемости параллельной реализации разложения Холецкого согласно [[Scalability methodology|методике]]. Исследование проводилось на суперкомпьютере "Ломоносов"<ref name="Lom">Воеводин Вл., Жуматий С., Соболев С., Антонов А., Брызгалов П., Никитенко Д., Стефанов К., Воеводин Вад. Практика суперкомпьютера «Ломоносов» // Открытые системы, 2012, N 7, С. 36-39.</ref> [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета].

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

* число процессоров [1 : 120];
* размер входных данных [1 : 15 000] верторок размерности 4.
При количестве кластеров 100.

[[file: Эффективность.jpg |thumb|center|700px|Изменение эффективности.]]

== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Можно найти следующие реализации алгоритма
* Для MATLAB http://www.mathworks.com/help/fuzzy/fcm.html
* В PostgreSQL http://num-meth.srcc.msu.ru/zhurnal/tom_2012/v13r207.html
Так же готовые реализации алгоритма и его описание можно найти на сайтах
* https://habrahabr.ru/post/208496/
* http://pythonhosted.org/scikit-fuzzy/auto_examples/plot_cmeans.html
* http://www.codeproject.com/Articles/91675/Computer-Vision-Applications-with-C-Fuzzy-C-means
* https://github.com/gyaikhom/fcm

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

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

2016-11-15T20:48:37Z

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

{{Assignment|ASA}}

{{algorithm
| name = Нечеткий алгоритм C средних
| serial_complexity = <math>O(C*C*K*I)</math>., где <math>I</math> - количество итераций
| input_data = <math>K*N</math>, [количество векторов * размерность]
| output_data = <math>C*K</math>, [элементы матрицы принадлежности]
| pf_height = <math>3I</math>
| pf_width = <math>C*C*K</math>
}}

Авторы : [[Участник:Protsenko|Мария Проценко]] (1.5-1.8, 2.7), [[Участник:ADovganich|Андрей Довганич]] (1.1-1.4, 1.9, 1.10)

= Свойства и структура алгоритмов =
== Общее описание алгоритма ==
Нечеткий алгоритм C-средних (fuzzy C-means) позволяет разбить имеющееся множество векторов (точек) мощностью <math>K</math> на заданное число нечетких множеств. Предназначен для кластеризации больших наборов данных. Основным достоинством алгоритма является нечеткость при определении объекта в кластер. Благодаря этому становится возможным определить объекты, которые находятся на границе, в кластеры. Из основного достоинства следует и главный недостаток - неопределенность с объектами, удаленными от центров всех кластеров. В остальном ему присущи стандартные проблемы подобного класса алгоритмов: вычислительная сложность, необходимость задания количества кластеров<ref>Нейский И.М. Классификация и сравнение методов кластеризации</ref>.

Алгоритм был разработан J.C. Dunn в 1973 г.<ref> Dunn, J. C. (1973-01-01). "A Fuzzy Relative of the ISODATA Process and Its Use in Detecting Compact Well-Separated Clusters". Journal of Cybernetics. 3 (3): 32–57. doi:10.1080/01969727308546046. ISSN 0022-0280.</ref>, усовершенствован J.C. Bezdek в 1981 г.<ref> Bezdek, James C. (1981). Pattern Recognition with Fuzzy Objective Function Algorithms. ISBN 0-306-40671-3.</ref>.

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

В общем виде алгоритм можно записать следующим образом:

# Инициализировать матрицу принадлежности;
# Вычислить центры кластеров;
# Вычислить значение решающей функции. Если значение ниже некоторого порогового или его улучшение по сравнению с предыдущей итерацией меньше определенной величины, то остановить вычисления;
# Иначе вычислить новые значения матрицы принадлежности;
# Перейти к шагу 2

== Математическое описание алгоритма ==
Рассмотрим матрицу <math> M = m_{ik} \in[0,1],\; i = 1, ..., c, \; k = 1, ..., K </math>. <math>m_{i,k}</math> - вероятность принадлежности объекта <math>k</math> к кластеру <math>i</math>; <math>c</math> - количество кластеров, <math>K</math> - количество векторов. При этом элементы матрицы удовлетворяют следующим условиям:

* сумма элементов в каждом столбце равна <math>1</math>;

* сумма всех элементов матрицы равно <math>K</math>;

Назовем <math> M </math> матрицей принадлежности.

Пусть <math>c_{i} (i = 1,2,...c)</math> - центры кластеров. Тогда рассмотрим функцию

<math>
\begin{align}
J(M, c_{1}, c_{2},...c_{c}) = \sum_{i = 1}^{c}{J_{i}} = \sum_{i = 1}^{c}\sum_{k = 1}^{K}{m_{ik}^q}d_{ik}^2 ~(1)
\end{align}
</math>

где <math> d_{ik} = \left\Vert{u_{k}-c_{i}}\right\| </math> - Евклидово расстояние между центром кластера и объектом, <math> 1 \le q \le \infty </math> - экспоненциальный весовой коэффициент, характеризующий нечеткость. Будем минимизировать значение функции <math> J </math>. Для этого вычислим центры кластеров по формуле <math> ~(2) </math>.

<math>c_{i} = {{\sum_{k = 1}^{K}{m_{ik}^q} * u_{k}} \over {\sum_{k = 1}^{K}{m_{ik}^q}}}~(2)</math>

где <math>m_{ik}</math> — коэффициент принадлежности <math>u_{k}</math> вектора к кластеру <math>c_{i}</math>

и новые значения матрицы <math> M </math> по формуле <math> ~(3) </math>

<math>m_{ik} = {1 \over \sum_{j = 1}^{c}{({{d_{ik}} \over {d_{jk}}})}^{2 \over q-1}} ~(3)</math>

<math> ~(2) </math> и <math> ~(3) </math>являются необходимым условиями достижения минимума функцией <math> J </math>. Таким образом эти два условия дают нам итерационный процесс.

Полностью алгоритм можно записать следующим образом:

# Инициализировать матрицу принадлежности <math> M </math> случайными значениями от 0 до 1;
# Вычислить центры кластеров <math>c_{i} (i = 1,2,...c)</math> используя формулу <math>~(2)</math>;
# Вычислить значение решающей функции по формуле <math>~(1)</math>. Если значение <math> J < \varepsilon,~\varepsilon > 0</math> или <math> |J_{i} - J_{i-1}| < \delta,~\delta > 0 </math>, то остановить вычисления;
# Иначе вычислить новые значения матрицы М по формуле <math>~(3)</math>;
# Перейти к шагу 2

== Вычислительное ядро алгоритма ==
Вычислительным ядром алгоритма являются формулы: <math> (1) </math>, <math> (2) </math>, <math> (3) </math>. В них производится вычисление новых центров кластеров, значения решающей функции и пересчет элементов матрицы принадлежности.

== Макроструктура алгоритма ==
Макроструктура алгоритма состоит из следующих шагов:

# Инициализация матрицы <math> M </math> случайными значениями от 0 до 1;
# Вычисление центров кластеров;
# Вычисление значения решающей функции(если оно удовлетворяет условиям останова - завершение вычислений);
# Вычисление новых элементов матрицы принадлежности;
# Переход к шагу 2;

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

Пример реализации алгоритма на языке С++. Сначала вычислим центры кластеров, потом вычислим решающую функцию, с ее помощью определим необходимость продолжать алгоритм, и при необходимости вычислим новые значения матрицы M.
<source lang="C++">

float ** m;
int *c;
int number_clusters, number_items;
m = gen_random_clusters();//заполним матрицу m случайными значениями от 0 до 1

while (true)
{
//вычисление центров кластеров
for (int i=0; i<number_clusters; i++)
{
numerator==denumerator=0;
for (int k=0; k<number_items; k++)
{
numerator+=pow(m[i, k], q)*u[k];//u[k]-вектор
denumerator+=pow(m[i, k], q);
}
c[i]= numerator / denumerator;//центры кластеров
}

j=0;//вычисление решающей функции
for (int i=0; i<number_clusters; i++)
for (int k=0; k<number_items; k++)
j+=pow(m[i, k], q)*pow(dist(c[i], x[k],2);//dist-вычисляет расстояние между заданными векторами

if ((abs(j-last_j)<delta) || (j<eps)) break;//проверка на необходимость завернешения алгоритма
last_j=j;
//обновление матрицы m
for (int i=0; i<number_clusters; i++)
for (int k=0; k<number_items; k++)
{
m[i,k]=0
for(int j=0; j<number_clusters; j++)
m[i,k]+=pow(dist(c[i], x[k])/dist(c[j], x[k]),2/(q-1));
m[i,k]=1/m[i,k];
}

}
</source>

== Последовательная сложность алгоритма ==
Каждая итерация включает в себя
* Вычисление центров кластеров <math>O(C*K)</math>
* Вычисление решающей функции <math>O(C*K)</math>
* Обновлене матрицы <math>M</math> <math>O(C*C*K)</math>
Общая сложность каждой итерации <math>O(C*C*K)</math>.

Сложность всего алгоритма будет зависеть от числа итераций, которое зависит от
* Выбора начального приближения
* Выбора условий останова

Окончательно, сложность алгоритма будет равна произведению количества итераций на их сложность

== Информационный граф ==
'''Первый ярус''' состоит из <math>C</math> параллельных операций, каждая их которых в свою очередь состоит из <math>K</math> параллельных операций, и одной, которая выполняется с использованием результата предыдущих.
Результатом работы этого яруса являются значения центров кластеров , которые будут использоваться на следующем ярусе.

'''Второй ярус''' содержит в себе <math>C*K</math> параллельных операций.
Результатом его работы является значение решающей функции <math>J</math>. Её значение определяет необходимость завершения алгоритма.

'''Третий ярус''' включает <math>C*K</math> параллельных операций, каждая из которых состоит из <math>C</math> параллельных операций, и одной, которая выполняется с использованием результата предыдущих.

[[Файл:Суперпрак.png|1200px|thumb|center|Информационный граф алгоритма. Салатовым цветом обозначены вершины графа-операции. Дугами обозначена передача информации, передаваемые данные надписаны сверху.]]

== Ресурс параллелизма алгоритма ==
На каждом шаге алгоритма необходимо вычислять сумму элементов массивов. Сложность ее вычисления на первом шаге (вычисление центров кластеров) при параллельной реализации составляет <math>O(\log_{2} C)</math>. Для каждого элемента из набора входных данных(<math> K </math>), но здесь возможен независимый расчет(координатный параллелизм). На втором шаге(вычисление решающей функции) сложность будет <math>O(\log_{2} {C*K})</math>, потому что здесь необходимо сложение всех элементов. На третьем шаге имеем сложность <math>O(\log_{2} C^2)</math>. Итого суммарная сложность итерации: <math>O(\log_{2} {C*K} + \log_{2} C^3)</math>. Воспользовавшись свойствами логарифма произведения получаем: <math>O(\log_{2} {K} + \log_{2} C^4)</math>.

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

== Входные и выходные данные алгоритма ==
Входные данные:
* <math>u_{k} ~k = 1, ..., K</math> - набор входных векторов размерности <math> N </math>;
* <math>C</math> - количество кластеров;
* <math>q</math> - экспоненциальный весовой коэффициент, характеризующий нечеткость;
* <math>\varepsilon > 0, ~\delta > 0</math> - коэффициенты, описывающие точность алгоритма.
Объем входных данных: <math> K*N </math>

Выходные данные:
* <math> M </math> - матрица принадлежности.
Объем выходных данных: <math> C*K </math>

== Свойства алгоритма ==
*Соотношение последовательной и параллельной сложности алгоритма: <math>C*C*K \over {\log_{2} {K} + \log_{2} C^4}</math>. Соответственно при распараллеливании наибольший прирост в производительности мы получим при разбиении большого набора данных на большее число кластеров;
*Вычислительная мощность: <math>{{C^2*K} \over {C*K}} = C</math>. Получается, что на чем большее количество кластеров мы разбиваем набор данных, тем менее затратным становится перемещение данных;
*Алгоритм не является устойчивым, как и другие подобные алгоритмы этого класса(например k-means). Очень многое зависит как от входных данных, так и от изначальных параметров приближения(заполнения матрицы принадлежности => исходных центров кластеров);
*Не является детерминированным. Так же очень многое зависит как от входных данных, так и от изначальных параметров приближения(заполнения матрицы принадлежности => исходных центров кластеров);
*Алгоритм не сбалансирован - доминирует операция умножения. Параллельные ветви алгоритма сбалансированы;
*Степень исхода вершины информационного графа - 2.

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

Исследование масштабируемости алгоритма проводилось на суперкомпьютере Ломоносов. Число процессоров изменялось до 1 до 120, а размеры входных данных от 1 до 15 000 векторов, размерности 4, при количестве кластеров 100.

[[file: Эффективность.jpg |thumb|center|700px|Изменение эффективности.]]

== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Можно найти следующие реализации алгоритма
* Для MATLAB http://www.mathworks.com/help/fuzzy/fcm.html
* В PostgreSQL http://num-meth.srcc.msu.ru/zhurnal/tom_2012/v13r207.html
Так же готовые реализации алгоритма и его описание можно найти на сайтах
* https://habrahabr.ru/post/208496/
* http://pythonhosted.org/scikit-fuzzy/auto_examples/plot_cmeans.html
* http://www.codeproject.com/Articles/91675/Computer-Vision-Applications-with-C-Fuzzy-C-means
* https://github.com/gyaikhom/fcm

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

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

2016-11-15T20:48:08Z

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

{{Assignment|ASA}}

{{algorithm
| name = Нечеткий алгоритм C средних
| serial_complexity = <math>O(C*C*K*I)</math>., где <math>I</math> - количество итераций
| input_data = <math>K*N</math>, [количество векторов * размерность]
| output_data = <math>C*K</math>, [элементы матрицы принадлежности]
| pf_height = <math>3I</math>
| pf_width = <math>C*C*K</math>
}}

Авторы : [[Участник:Protsenko|Мария Проценко]] (1.5-1.8, 2.7), [[Участник:ADovganich|Андрей Довганич]] (1.1-1.4, 1.9, 1.10)

= Свойства и структура алгоритмов =
== Общее описание алгоритма ==
Нечеткий алгоритм C-средних (fuzzy C-means) позволяет разбить имеющееся множество векторов (точек) мощностью <math>K</math> на заданное число нечетких множеств. Предназначен для кластеризации больших наборов данных. Основным достоинством алгоритма является нечеткость при определении объекта в кластер. Благодаря этому становится возможным определить объекты, которые находятся на границе, в кластеры. Из основного достоинства следует и главный недостаток - неопределенность с объектами, удаленными от центров всех кластеров. В остальном ему присущи стандартные проблемы подобного класса алгоритмов: вычислительная сложность, необходимость задания количества кластеров<ref>Нейский И.М. Классификация и сравнение методов кластеризации</ref>.

Алгоритм был разработан J.C. Dunn в 1973 г.<ref> Dunn, J. C. (1973-01-01). "A Fuzzy Relative of the ISODATA Process and Its Use in Detecting Compact Well-Separated Clusters". Journal of Cybernetics. 3 (3): 32–57. doi:10.1080/01969727308546046. ISSN 0022-0280.</ref>, усовершенствован J.C. Bezdek в 1981 г.<ref> Bezdek, James C. (1981). Pattern Recognition with Fuzzy Objective Function Algorithms. ISBN 0-306-40671-3.</ref>.

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

В общем виде алгоритм можно записать следующим образом:

# Инициализировать матрицу принадлежности;
# Вычислить центры кластеров;
# Вычислить значение решающей функции. Если значение ниже некоторого порогового или его улучшение по сравнению с предыдущей итерацией меньше определенной величины, то остановить вычисления;
# Иначе вычислить новые значения матрицы принадлежности;
# Перейти к шагу 2

== Математическое описание алгоритма ==
Рассмотрим матрицу <math> M = m_{ik} \in[0,1],\; i = 1, ..., c, \; k = 1, ..., K </math>. <math>m_{i,k}</math> - вероятность принадлежности объекта <math>k</math> к кластеру <math>i</math>; <math>c</math> - количество кластеров, <math>K</math> - количество векторов. При этом элементы матрицы удовлетворяют следующим условиям:

* сумма элементов в каждом столбце равна <math>1</math>;

* сумма всех элементов матрицы равно <math>K</math>;

Назовем <math> M </math> матрицей принадлежности.

Пусть <math>c_{i} (i = 1,2,...c)</math> - центры кластеров. Тогда рассмотрим функцию

<math>
\begin{align}
J(M, c_{1}, c_{2},...c_{c}) = \sum_{i = 1}^{c}{J_{i}} = \sum_{i = 1}^{c}\sum_{k = 1}^{K}{m_{ik}^q}d_{ik}^2 ~(1)
\end{align}
</math>

где <math> d_{ik} = \left\Vert{u_{k}-c_{i}}\right\| </math> - Евклидово расстояние между центром кластера и объектом, <math> 1 \le q \le \infty </math> - экспоненциальный весовой коэффициент, характеризующий нечеткость. Будем минимизировать значение функции <math> J </math>. Для этого вычислим центры кластеров по формуле <math> ~(2) </math>.

<math>c_{i} = {{\sum_{k = 1}^{K}{m_{ik}^q} * u_{k}} \over {\sum_{k = 1}^{K}{m_{ik}^q}}}~(2)</math>

где <math>m_{ik}</math> — коэффициент принадлежности <math>u_{k}</math> вектора к кластеру <math>c_{i}</math>

и новые значения матрицы <math> M </math> по формуле <math> ~(3) </math>

<math>m_{ik} = {1 \over \sum_{j = 1}^{c}{({{d_{ik}} \over {d_{jk}}})}^{2 \over q-1}} ~(3)</math>

<math> ~(2) </math> и <math> ~(3) </math>являются необходимым условиями достижения минимума функцией <math> J </math>. Таким образом эти два условия дают нам итерационный процесс.

Полностью алгоритм можно записать следующим образом:

# Инициализировать матрицу принадлежности <math> M </math> случайными значениями от 0 до 1;
# Вычислить центры кластеров <math>c_{i} (i = 1,2,...c)</math> используя формулу <math>~(2)</math>;
# Вычислить значение решающей функции по формуле <math>~(1)</math>. Если значение <math> J < \varepsilon,~\varepsilon > 0</math> или <math> |J_{i} - J_{i-1}| < \delta,~\delta > 0 </math>, то остановить вычисления;
# Иначе вычислить новые значения матрицы М по формуле <math>~(3)</math>;
# Перейти к шагу 2

== Вычислительное ядро алгоритма ==
Вычислительным ядром алгоритма являются формулы: <math> (1) </math>, <math> (2) </math>, <math> (3) </math>. В них производится вычисление новых центров кластеров, значения решающей функции и пересчет элементов матрицы принадлежности.

== Макроструктура алгоритма ==
Макроструктура алгоритма состоит из следующих шагов:

# Инициализация матрицы <math> M </math> случайными значениями от 0 до 1;
# Вычисление центров кластеров;
# Вычисление значения решающей функции(если оно удовлетворяет условиям останова - завершение вычислений);
# Вычисление новых элементов матрицы принадлежности;
# Переход к шагу 2;

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

Пример реализации алгоритма на языке С++. Сначала вычислим центры кластеров, потом вычислим решающую функцию, с ее помощью определим необходимость продолжать алгоритм, и при необходимости вычислим новые значения матрицы M.
<source lang="C++">

float ** m;
int *c;
int number_clusters, number_items;
m = gen_random_clusters();//заполним матрицу m случайными значениями от 0 до 1

while (true)
{
//вычисление центров кластеров
for (int i=0; i<number_clusters; i++)
{
numerator==denumerator=0;
for (int k=0; k<number_items; k++)
{
numerator+=pow(m[i, k], q)*u[k];//u[k]-вектор
denumerator+=pow(m[i, k], q);
}
c[i]= numerator / denumerator;//центры кластеров
}

j=0;//вычисление решающей функции
for (int i=0; i<number_clusters; i++)
for (int k=0; k<number_items; k++)
j+=pow(m[i, k], q)*pow(dist(c[i], x[k],2);//dist-вычисляет расстояние между заданными векторами

if ((abs(j-last_j)<delta) || (j<eps)) break;//проверка на необходимость завернешения алгоритма
last_j=j;
//обновление матрицы m
for (int i=0; i<number_clusters; i++)
for (int k=0; k<number_items; k++)
{
m[i,k]=0
for(int j=0; j<number_clusters; j++)
m[i,k]+=pow(dist(c[i], x[k])/dist(c[j], x[k]),2/(q-1));
m[i,k]=1/m[i,k];
}

}
</source>

== Последовательная сложность алгоритма ==
Каждая итерация включает в себя
* Вычисление центров кластеров <math>O(C*K)</math>
* Вычисление решающей функции <math>O(C*K)</math>
* Обновлене матрицы <math>M</math> <math>O(C*C*K)</math>
Общая сложность каждой итерации <math>O(C*C*K)</math>.

Сложность всего алгоритма будет зависеть от числа итераций, которое зависит от
* Выбора начального приближения
* Выбора условий останова

Окончательно, сложность алгоритма будет равна произведению количества итераций на их сложность

== Информационный граф ==
'''Первый ярус''' состоит из <math>C</math> параллельных операций, каждая их которых в свою очередь состоит из <math>K</math> параллельных операций, и одной, которая выполняется с использованием результата предыдущих.
Результатом работы этого яруса являются значения центров кластеров , которые будут использоваться на следующем ярусе.

'''Второй ярус''' содержит в себе <math>C*K</math> параллельных операций.
Результатом его работы является значение решающей функции <math>J</math>. Её значение определяет необходимость завершения алгоритма.

'''Третий ярус''' включает <math>C*K</math> параллельных операций, каждая из которых состоит из <math>C</math> параллельных операций, и одной, которая выполняется с использованием результата предыдущих.

[[Файл:Суперпрак.png|1200px|thumb|center|Информационный граф алгоритма. Салатовым цветом обозначены вершины графа-операции. Дугами обозначена передача информации, передаваемые данные надписаны сверху.]]

== Ресурс параллелизма алгоритма ==
На каждом шаге алгоритма необходимо вычислять сумму элементов массивов. Сложность ее вычисления на первом шаге (вычисление центров кластеров) при параллельной реализации составляет <math>O(\log_{2} C)</math>. Для каждого элемента из набора входных данных(<math> K </math>), но здесь возможен независимый расчет(координатный параллелизм). На втором шаге(вычисление решающей функции) сложность будет <math>O(\log_{2} {C*K})</math>, потому что здесь необходимо сложение всех элементов. На третьем шаге имеем сложность <math>O(\log_{2} C^2)</math>. Итого суммарная сложность итерации: <math>O(\log_{2} {C*K} + \log_{2} C^3)</math>. Воспользовавшись свойствами логарифма произведения получаем: <math>O(\log_{2} {K} + \log_{2} C^4)</math>.

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

== Входные и выходные данные алгоритма ==
Входные данные:
* <math>u_{k} ~k = 1, ..., K</math> - набор входных векторов размерности <math> N </math>;
* <math>C</math> - количество кластеров;
* <math>q</math> - экспоненциальный весовой коэффициент, характеризующий нечеткость;
* <math>\varepsilon > 0, ~\delta > 0</math> - коэффициенты, описывающие точность алгоритма.
Объем входных данных: <math> K*N </math>

Выходные данные:
* <math> M </math> - матрица принадлежности.
Объем выходных данных: <math> C*K </math>

== Свойства алгоритма ==
*Соотношение последовательной и параллельной сложности алгоритма: <math>C*C*K \over {\log_{2} {K} + \log_{2} C^4}</math>. Соответственно при распараллеливании наибольший прирост в производительности мы получим при разбиении большого набора данных на большее число кластеров;
*Вычислительная мощность: <math>{{C^2*K} \over {C*K}} = C</math>. Получается, что на чем большее количество кластеров мы разбиваем набор данных, тем менее затратным становится перемещение данных;
*Алгоритм не является устойчивым, как и другие подобные алгоритмы этого класса(например k-means). Очень многое зависит как от входных данных, так и от изначальных параметров приближения(заполнения матрицы принадлежности => исходных центров кластеров);
*Не является детерминированным. Так же очень многое зависит как от входных данных, так и от изначальных параметров приближения(заполнения матрицы принадлежности => исходных центров кластеров);
*Алгоритм не сбалансирован - доминирует операция умножения. Параллельные ветви алгоритма сбалансированы;
*Степень исхода вершины информационного графа - 2.

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

Исследование масштабируемости алгоритма проводилось на суперкомпьютере Ломоносов. Число процессоров изменялось до 1 до 119, а размеры входных данных от 1 до 15 000 векторов, размерности 4, при количестве кластеров 100.

[[file: Эффективность.jpg |thumb|center|700px|Изменение эффективности.]]

== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Можно найти следующие реализации алгоритма
* Для MATLAB http://www.mathworks.com/help/fuzzy/fcm.html
* В PostgreSQL http://num-meth.srcc.msu.ru/zhurnal/tom_2012/v13r207.html
Так же готовые реализации алгоритма и его описание можно найти на сайтах
* https://habrahabr.ru/post/208496/
* http://pythonhosted.org/scikit-fuzzy/auto_examples/plot_cmeans.html
* http://www.codeproject.com/Articles/91675/Computer-Vision-Applications-with-C-Fuzzy-C-means
* https://github.com/gyaikhom/fcm

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

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

2016-11-15T20:47:53Z

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

{{Assignment|ASA}}

{{algorithm
| name = Нечеткий алгоритм C средних
| serial_complexity = <math>O(C*C*K*I)</math>., где <math>I</math> - количество итераций
| input_data = <math>K*N</math>, [количество векторов * размерность]
| output_data = <math>C*K</math>, [элементы матрицы принадлежности]
| pf_height = <math>3I</math>
| pf_width = <math>C*C*K</math>
}}

Авторы : [[Участник:Protsenko|Мария Проценко]] (1.5-1.8, 2.7), [[Участник:ADovganich|Андрей Довганич]] (1.1-1.4, 1.9, 1.10)

= Свойства и структура алгоритмов =
== Общее описание алгоритма ==
Нечеткий алгоритм C-средних (fuzzy C-means) позволяет разбить имеющееся множество векторов (точек) мощностью <math>K</math> на заданное число нечетких множеств. Предназначен для кластеризации больших наборов данных. Основным достоинством алгоритма является нечеткость при определении объекта в кластер. Благодаря этому становится возможным определить объекты, которые находятся на границе, в кластеры. Из основного достоинства следует и главный недостаток - неопределенность с объектами, удаленными от центров всех кластеров. В остальном ему присущи стандартные проблемы подобного класса алгоритмов: вычислительная сложность, необходимость задания количества кластеров<ref>Нейский И.М. Классификация и сравнение методов кластеризации</ref>.

Алгоритм был разработан J.C. Dunn в 1973 г.<ref> Dunn, J. C. (1973-01-01). "A Fuzzy Relative of the ISODATA Process and Its Use in Detecting Compact Well-Separated Clusters". Journal of Cybernetics. 3 (3): 32–57. doi:10.1080/01969727308546046. ISSN 0022-0280.</ref>, усовершенствован J.C. Bezdek в 1981 г.<ref> Bezdek, James C. (1981). Pattern Recognition with Fuzzy Objective Function Algorithms. ISBN 0-306-40671-3.</ref>.

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

В общем виде алгоритм можно записать следующим образом:

# Инициализировать матрицу принадлежности;
# Вычислить центры кластеров;
# Вычислить значение решающей функции. Если значение ниже некоторого порогового или его улучшение по сравнению с предыдущей итерацией меньше определенной величины, то остановить вычисления;
# Иначе вычислить новые значения матрицы принадлежности;
# Перейти к шагу 2

== Математическое описание алгоритма ==
Рассмотрим матрицу <math> M = m_{ik} \in[0,1],\; i = 1, ..., c, \; k = 1, ..., K </math>. <math>m_{i,k}</math> - вероятность принадлежности объекта <math>k</math> к кластеру <math>i</math>; <math>c</math> - количество кластеров, <math>K</math> - количество векторов. При этом элементы матрицы удовлетворяют следующим условиям:

* сумма элементов в каждом столбце равна <math>1</math>;

* сумма всех элементов матрицы равно <math>K</math>;

Назовем <math> M </math> матрицей принадлежности.

Пусть <math>c_{i} (i = 1,2,...c)</math> - центры кластеров. Тогда рассмотрим функцию

<math>
\begin{align}
J(M, c_{1}, c_{2},...c_{c}) = \sum_{i = 1}^{c}{J_{i}} = \sum_{i = 1}^{c}\sum_{k = 1}^{K}{m_{ik}^q}d_{ik}^2 ~(1)
\end{align}
</math>

где <math> d_{ik} = \left\Vert{u_{k}-c_{i}}\right\| </math> - Евклидово расстояние между центром кластера и объектом, <math> 1 \le q \le \infty </math> - экспоненциальный весовой коэффициент, характеризующий нечеткость. Будем минимизировать значение функции <math> J </math>. Для этого вычислим центры кластеров по формуле <math> ~(2) </math>.

<math>c_{i} = {{\sum_{k = 1}^{K}{m_{ik}^q} * u_{k}} \over {\sum_{k = 1}^{K}{m_{ik}^q}}}~(2)</math>

где <math>m_{ik}</math> — коэффициент принадлежности <math>u_{k}</math> вектора к кластеру <math>c_{i}</math>

и новые значения матрицы <math> M </math> по формуле <math> ~(3) </math>

<math>m_{ik} = {1 \over \sum_{j = 1}^{c}{({{d_{ik}} \over {d_{jk}}})}^{2 \over q-1}} ~(3)</math>

<math> ~(2) </math> и <math> ~(3) </math>являются необходимым условиями достижения минимума функцией <math> J </math>. Таким образом эти два условия дают нам итерационный процесс.

Полностью алгоритм можно записать следующим образом:

# Инициализировать матрицу принадлежности <math> M </math> случайными значениями от 0 до 1;
# Вычислить центры кластеров <math>c_{i} (i = 1,2,...c)</math> используя формулу <math>~(2)</math>;
# Вычислить значение решающей функции по формуле <math>~(1)</math>. Если значение <math> J < \varepsilon,~\varepsilon > 0</math> или <math> |J_{i} - J_{i-1}| < \delta,~\delta > 0 </math>, то остановить вычисления;
# Иначе вычислить новые значения матрицы М по формуле <math>~(3)</math>;
# Перейти к шагу 2

== Вычислительное ядро алгоритма ==
Вычислительным ядром алгоритма являются формулы: <math> (1) </math>, <math> (2) </math>, <math> (3) </math>. В них производится вычисление новых центров кластеров, значения решающей функции и пересчет элементов матрицы принадлежности.

== Макроструктура алгоритма ==
Макроструктура алгоритма состоит из следующих шагов:

# Инициализация матрицы <math> M </math> случайными значениями от 0 до 1;
# Вычисление центров кластеров;
# Вычисление значения решающей функции(если оно удовлетворяет условиям останова - завершение вычислений);
# Вычисление новых элементов матрицы принадлежности;
# Переход к шагу 2;

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

Пример реализации алгоритма на языке С++. Сначала вычислим центры кластеров, потом вычислим решающую функцию, с ее помощью определим необходимость продолжать алгоритм, и при необходимости вычислим новые значения матрицы M.
<source lang="C++">

float ** m;
int *c;
int number_clusters, number_items;
m = gen_random_clusters();//заполним матрицу m случайными значениями от 0 до 1

while (true)
{
//вычисление центров кластеров
for (int i=0; i<number_clusters; i++)
{
numerator==denumerator=0;
for (int k=0; k<number_items; k++)
{
numerator+=pow(m[i, k], q)*u[k];//u[k]-вектор
denumerator+=pow(m[i, k], q);
}
c[i]= numerator / denumerator;//центры кластеров
}

j=0;//вычисление решающей функции
for (int i=0; i<number_clusters; i++)
for (int k=0; k<number_items; k++)
j+=pow(m[i, k], q)*pow(dist(c[i], x[k],2);//dist-вычисляет расстояние между заданными векторами

if ((abs(j-last_j)<delta) || (j<eps)) break;//проверка на необходимость завернешения алгоритма
last_j=j;
//обновление матрицы m
for (int i=0; i<number_clusters; i++)
for (int k=0; k<number_items; k++)
{
m[i,k]=0
for(int j=0; j<number_clusters; j++)
m[i,k]+=pow(dist(c[i], x[k])/dist(c[j], x[k]),2/(q-1));
m[i,k]=1/m[i,k];
}

}
</source>

== Последовательная сложность алгоритма ==
Каждая итерация включает в себя
* Вычисление центров кластеров <math>O(C*K)</math>
* Вычисление решающей функции <math>O(C*K)</math>
* Обновлене матрицы <math>M</math> <math>O(C*C*K)</math>
Общая сложность каждой итерации <math>O(C*C*K)</math>.

Сложность всего алгоритма будет зависеть от числа итераций, которое зависит от
* Выбора начального приближения
* Выбора условий останова

Окончательно, сложность алгоритма будет равна произведению количества итераций на их сложность

== Информационный граф ==
'''Первый ярус''' состоит из <math>C</math> параллельных операций, каждая их которых в свою очередь состоит из <math>K</math> параллельных операций, и одной, которая выполняется с использованием результата предыдущих.
Результатом работы этого яруса являются значения центров кластеров , которые будут использоваться на следующем ярусе.

'''Второй ярус''' содержит в себе <math>C*K</math> параллельных операций.
Результатом его работы является значение решающей функции <math>J</math>. Её значение определяет необходимость завершения алгоритма.

'''Третий ярус''' включает <math>C*K</math> параллельных операций, каждая из которых состоит из <math>C</math> параллельных операций, и одной, которая выполняется с использованием результата предыдущих.

[[Файл:Суперпрак.png|1200px|thumb|center|Информационный граф алгоритма. Салатовым цветом обозначены вершины графа-операции. Дугами обозначена передача информации, передаваемые данные надписаны сверху.]]

== Ресурс параллелизма алгоритма ==
На каждом шаге алгоритма необходимо вычислять сумму элементов массивов. Сложность ее вычисления на первом шаге (вычисление центров кластеров) при параллельной реализации составляет <math>O(\log_{2} C)</math>. Для каждого элемента из набора входных данных(<math> K </math>), но здесь возможен независимый расчет(координатный параллелизм). На втором шаге(вычисление решающей функции) сложность будет <math>O(\log_{2} {C*K})</math>, потому что здесь необходимо сложение всех элементов. На третьем шаге имеем сложность <math>O(\log_{2} C^2)</math>. Итого суммарная сложность итерации: <math>O(\log_{2} {C*K} + \log_{2} C^3)</math>. Воспользовавшись свойствами логарифма произведения получаем: <math>O(\log_{2} {K} + \log_{2} C^4)</math>.

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

== Входные и выходные данные алгоритма ==
Входные данные:
* <math>u_{k} ~k = 1, ..., K</math> - набор входных векторов размерности <math> N </math>;
* <math>C</math> - количество кластеров;
* <math>q</math> - экспоненциальный весовой коэффициент, характеризующий нечеткость;
* <math>\varepsilon > 0, ~\delta > 0</math> - коэффициенты, описывающие точность алгоритма.
Объем входных данных: <math> K*N </math>

Выходные данные:
* <math> M </math> - матрица принадлежности.
Объем выходных данных: <math> C*K </math>

== Свойства алгоритма ==
*Соотношение последовательной и параллельной сложности алгоритма: <math>C*C*K \over {\log_{2} {K} + \log_{2} C^4}</math>. Соответственно при распараллеливании наибольший прирост в производительности мы получим при разбиении большого набора данных на большее число кластеров;
*Вычислительная мощность: <math>{{C^2*K} \over {C*K}} = C</math>. Получается, что на чем большее количество кластеров мы разбиваем набор данных, тем менее затратным становится перемещение данных;
*Алгоритм не является устойчивым, как и другие подобные алгоритмы этого класса(например k-means). Очень многое зависит как от входных данных, так и от изначальных параметров приближения(заполнения матрицы принадлежности => исходных центров кластеров);
*Не является детерминированным. Так же очень многое зависит как от входных данных, так и от изначальных параметров приближения(заполнения матрицы принадлежности => исходных центров кластеров);
*Алгоритм не сбалансирован - доминирует операция умножения. Параллельные ветви алгоритма сбалансированы;
*Степень исхода вершины информационного графа - 2.

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

Исследование масштабируемости алгоритма проводилось на суперкомпьютере Ломоносов. Число процессоров изменялось до 1 до 119, а размеры входных данных от 1 до 15 000 векторов, размерности 4, при количестве кластеров 100.
На следующих рисунках приведены графики [[Глоссарий#Производительность|производительности]] и эффективности выбранной реализации в зависимости от изменяемых параметров запуска.

[[file: Эффективность.jpg |thumb|center|700px|Изменение эффективности.]]

== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Можно найти следующие реализации алгоритма
* Для MATLAB http://www.mathworks.com/help/fuzzy/fcm.html
* В PostgreSQL http://num-meth.srcc.msu.ru/zhurnal/tom_2012/v13r207.html
Так же готовые реализации алгоритма и его описание можно найти на сайтах
* https://habrahabr.ru/post/208496/
* http://pythonhosted.org/scikit-fuzzy/auto_examples/plot_cmeans.html
* http://www.codeproject.com/Articles/91675/Computer-Vision-Applications-with-C-Fuzzy-C-means
* https://github.com/gyaikhom/fcm

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

Файл:Эффективность.jpg

2016-11-15T20:47:37Z

Protsenko:

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

2016-11-02T12:42:25Z

Protsenko: /* Замечания по тексту */

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

=== Замечания по тексту ===
* В разделе 1.5 кроме текста программы нужны словесные пояснения. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 16:38, 27 октября 2016 (MSK)
* Граф, представленный в разделе 1.7, не является информационным графом (ациклический граф, вершины - операции, дуги - информационные зависимости). [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 16:38, 27 октября 2016 (MSK)
** Приведённый граф по-прежнему является графом управления, а не информационным графом: содержит цикл, ветвление и т.д. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 11:31, 1 ноября 2016 (MSK)

* В разделе 1.9 требуется привести оценки объёма входных и выходных данных. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 16:38, 27 октября 2016 (MSK)

Исправлено

Граф исправлен еще раз

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

2016-11-02T12:41:38Z

Protsenko:

{{Assignment}}

{{algorithm
| name = Нечеткий алгоритм C средних
| serial_complexity = <math>O(C*C*K*I)</math>., где <math>I</math> - количество итераций
| input_data = <math>K*N</math>, [количество векторов * размерность]
| output_data = <math>C*K</math>, [элементы матрицы принадлежности]
| pf_height = <math>3I</math>
| pf_width = <math>C*C*K</math>
}}

Авторы : [[Участник:Protsenko|Мария Проценко]] (1.5-1.8, 2.7), [[Участник:ADovganich|Андрей Довганич]] (1.1-1.4, 1.9, 1.10)

= Свойства и структура алгоритмов =
== Общее описание алгоритма ==
Нечеткий алгоритм C-средних (fuzzy C-means) позволяет разбить имеющееся множество векторов (точек) мощностью <math>K</math> на заданное число нечетких множеств. Предназначен для кластеризации больших наборов данных. Основным достоинством алгоритма является нечеткость при определении объекта в кластер. Благодаря этому становится возможным определить объекты, которые находятся на границе, в кластеры. Из основного достоинства следует и главный недостаток - неопределенность с объектами, удаленными от центров всех кластеров. В остальном ему присущи стандартные проблемы подобного класса алгоритмов: вычислительная сложность, необходимость задания количества кластеров<ref>Нейский И.М. Классификация и сравнение методов кластеризации</ref>.

Алгоритм был разработан J.C. Dunn в 1973 г.<ref> Dunn, J. C. (1973-01-01). "A Fuzzy Relative of the ISODATA Process and Its Use in Detecting Compact Well-Separated Clusters". Journal of Cybernetics. 3 (3): 32–57. doi:10.1080/01969727308546046. ISSN 0022-0280.</ref>, усовершенствован J.C. Bezdek в 1981 г.<ref> Bezdek, James C. (1981). Pattern Recognition with Fuzzy Objective Function Algorithms. ISBN 0-306-40671-3.</ref>.

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

В общем виде алгоритм можно записать следующим образом:

# Инициализировать матрицу принадлежности;
# Вычислить центры кластеров;
# Вычислить значение решающей функции. Если значение ниже некоторого порогового или его улучшение по сравнению с предыдущей итерацией меньше определенной величины, то остановить вычисления;
# Иначе вычислить новые значения матрицы принадлежности;
# Перейти к шагу 2

== Математическое описание алгоритма ==
Рассмотрим матрицу <math> M = m_{ik} \in[0,1],\; i = 1, ..., c, \; k = 1, ..., K </math>. <math>m_{i,k}</math> - вероятность принадлежности объекта <math>k</math> к кластеру <math>i</math>; <math>c</math> - количество кластеров, <math>K</math> - количество векторов. При этом элементы матрицы удовлетворяют следующим условиям:

* сумма элементов в каждом столбце равна <math>1</math>;

* сумма всех элементов матрицы равно <math>K</math>;

Назовем <math> M </math> матрицей принадлежности.

Пусть <math>c_{i} (i = 1,2,...c)</math> - центры кластеров. Тогда рассмотрим функцию

<math>
\begin{align}
J(M, c_{1}, c_{2},...c_{c}) = \sum_{i = 1}^{c}{J_{i}} = \sum_{i = 1}^{c}\sum_{k = 1}^{K}{m_{ik}^q}d_{ik}^2 ~(1)
\end{align}
</math>

где <math> d_{ik} = \left\Vert{u_{k}-c_{i}}\right\| </math> - Евклидово расстояние между центром кластера и объектом, <math> 1 \le q \le \infty </math> - экспоненциальный весовой коэффициент, характеризующий нечеткость. Будем минимизировать значение функции <math> J </math>. Для этого вычислим центры кластеров по формуле <math> ~(2) </math>.

<math>c_{i} = {{\sum_{k = 1}^{K}{m_{ik}^q} * u_{k}} \over {\sum_{k = 1}^{K}{m_{ik}^q}}}~(2)</math>

где <math>m_{ik}</math> — коэффициент принадлежности <math>u_{k}</math> вектора к кластеру <math>c_{i}</math>

и новые значения матрицы <math> M </math> по формуле <math> ~(3) </math>

<math>m_{ik} = {1 \over \sum_{j = 1}^{c}{({{d_{ik}} \over {d_{jk}}})}^{2 \over q-1}} ~(3)</math>

<math> ~(2) </math> и <math> ~(3) </math>являются необходимым условиями достижения минимума функцией <math> J </math>. Таким образом эти два условия дают нам итерационный процесс.

Полностью алгоритм можно записать следующим образом:

# Инициализировать матрицу принадлежности <math> M </math> случайными значениями от 0 до 1;
# Вычислить центры кластеров <math>c_{i} (i = 1,2,...c)</math> используя формулу <math>~(2)</math>;
# Вычислить значение решающей функции по формуле <math>~(1)</math>. Если значение <math> J < \varepsilon,~\varepsilon > 0</math> или <math> |J_{i} - J_{i-1}| < \delta,~\delta > 0 </math>, то остановить вычисления;
# Иначе вычислить новые значения матрицы М по формуле <math>~(3)</math>;
# Перейти к шагу 2

== Вычислительное ядро алгоритма ==
Вычислительным ядром алгоритма являются формулы: <math> (1) </math>, <math> (2) </math>, <math> (3) </math>. В них производится вычисление новых центров кластеров, значения решающей функции и пересчет элементов матрицы принадлежности.

== Макроструктура алгоритма ==
Макроструктура алгоритма состоит из следующих шагов:

# Инициализация матрицы <math> M </math> случайными значениями от 0 до 1;
# Вычисление центров кластеров;
# Вычисление значения решающей функции(если оно удовлетворяет условиям останова - завершение вычислений);
# Вычисление новых элементов матрицы принадлежности;
# Переход к шагу 2;

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

Пример реализации алгоритма на языке С++. Сначала вычислим центры кластеров, потом вычислим решающую функцию, с ее помощью определим необходимость продолжать алгоритм, и при необходимости вычислим новые значения матрицы M.
<source lang="C++">

float ** m;
int *c;
int number_clusters, number_items;
m = gen_random_clusters();//заполним матрицу m случайными значениями от 0 до 1

while (true)
{
//вычисление центров кластеров
for (int i=0; i<number_clusters; i++)
{
numerator==denumerator=0;
for (int k=0; k<number_items; k++)
{
numerator+=pow(m[i, k], q)*u[k];//u[k]-вектор
denumerator+=pow(m[i, k], q);
}
c[i]= numerator / denumerator;//центры кластеров
}

j=0;//вычисление решающей функции
for (int i=0; i<number_clusters; i++)
for (int k=0; k<number_items; k++)
j+=pow(m[i, k], q)*pow(dist(c[i], x[k],2);//dist-вычисляет расстояние между заданными векторами

if ((abs(j-last_j)<delta) || (j<eps)) break;//проверка на необходимость завернешения алгоритма
last_j=j;
//обновление матрицы m
for (int i=0; i<number_clusters; i++)
for (int k=0; k<number_items; k++)
{
m[i,k]=0
for(int j=0; j<number_clusters; j++)
m[i,k]+=pow(dist(c[i], x[k])/dist(c[j], x[k]),2/(q-1));
m[i,k]=1/m[i,k];
}

}
</source>

== Последовательная сложность алгоритма ==
Каждая итерация включает в себя
* Вычисление центров кластеров <math>O(C*K)</math>
* Вычисление решающей функции <math>O(C*K)</math>
* Обновлене матрицы <math>M</math> <math>O(C*C*K)</math>
Общая сложность каждой итерации <math>O(C*C*K)</math>.

Сложность всего алгоритма будет зависеть от числа итераций, которое зависит от
* Выбора начального приближения
* Выбора условий останова

Окончательно, сложность алгоритма будет равна произведению количества итераций на их сложность

== Информационный граф ==
'''Первый ярус''' состоит из <math>C</math> параллельных операций, каждая их которых в свою очередь состоит из <math>K</math> параллельных операций, и одной, которая выполняется с использованием результата предыдущих.
Результатом работы этого яруса являются значения центров кластеров , которые будут использоваться на следующем ярусе.

'''Второй ярус''' содержит в себе <math>C*K</math> параллельных операций.
Результатом его работы является значение решающей функции <math>J</math>. Её значение определяет необходимость завершения алгоритма.

'''Третий ярус''' включает <math>C*K</math> параллельных операций, каждая из которых состоит из <math>C</math> параллельных операций, и одной, которая выполняется с использованием результата предыдущих.

[[Файл:Суперпрак.png|1200px|thumb|center|Информационный граф алгоритма. Салатовым цветом обозначены вершины графа-операции. Дугами обозначена передача информации, передаваемые данные надписаны сверху.]]

== Ресурс параллелизма алгоритма ==
На каждом шаге алгоритма необходимо вычислять сумму элементов массивов. Сложность ее вычисления на первом шаге (вычисление центров кластеров) при параллельной реализации составляет <math>O(\log_{2} C)</math>. Для каждого элемента из набора входных данных(<math> K </math>), но здесь возможен независимый расчет(координатный параллелизм). На втором шаге(вычисление решающей функции) сложность будет <math>O(\log_{2} {C*K})</math>, потому что здесь необходимо сложение всех элементов. На третьем шаге имеем сложность <math>O(\log_{2} C^2)</math>. Итого суммарная сложность итерации: <math>O(\log_{2} {C*K} + \log_{2} C^3)</math>. Воспользовавшись свойствами логарифма произведения получаем: <math>O(\log_{2} {K} + \log_{2} C^4)</math>.

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

== Входные и выходные данные алгоритма ==
Входные данные:
* <math>u_{k} ~k = 1, ..., K</math> - набор входных векторов размерности <math> N </math>;
* <math>C</math> - количество кластеров;
* <math>q</math> - экспоненциальный весовой коэффициент, характеризующий нечеткость;
* <math>\varepsilon > 0, ~\delta > 0</math> - коэффициенты, описывающие точность алгоритма.
Объем входных данных: <math> K*N </math>

Выходные данные:
* <math> M </math> - матрица принадлежности.
Объем выходных данных: <math> C*K </math>

== Свойства алгоритма ==
*Соотношение последовательной и параллельной сложности алгоритма: <math>C*C*K \over {\log_{2} {K} + \log_{2} C^4}</math>. Соответственно при распараллеливании наибольший прирост в производительности мы получим при разбиении большого набора данных на большее число кластеров;
*Вычислительная мощность: <math>{{C^2*K} \over {C*K}} = C</math>. Получается, что на чем большее количество кластеров мы разбиваем набор данных, тем менее затратным становится перемещение данных;
*Алгоритм не является устойчивым, как и другие подобные алгоритмы этого класса(например k-means). Очень многое зависит как от входных данных, так и от изначальных параметров приближения(заполнения матрицы принадлежности => исходных центров кластеров);
*Не является детерминированным. Так же очень многое зависит как от входных данных, так и от изначальных параметров приближения(заполнения матрицы принадлежности => исходных центров кластеров);
*Алгоритм не сбалансирован - доминирует операция умножения. Параллельные ветви алгоритма сбалансированы;
*Степень исхода вершины информационного графа - 2.

= Программная реализация алгоритма =
== Особенности реализации последовательного алгоритма ==
== Локальность данных и вычислений ==
== Возможные способы и особенности параллельной реализации алгоритма ==
== Масштабируемость алгоритма и его реализации ==
== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Можно найти следующие реализации алгоритма
* Для MATLAB http://www.mathworks.com/help/fuzzy/fcm.html
* В PostgreSQL http://num-meth.srcc.msu.ru/zhurnal/tom_2012/v13r207.html
Так же готовые реализации алгоритма и его описание можно найти на сайтах
* https://habrahabr.ru/post/208496/
* http://pythonhosted.org/scikit-fuzzy/auto_examples/plot_cmeans.html
* http://www.codeproject.com/Articles/91675/Computer-Vision-Applications-with-C-Fuzzy-C-means
* https://github.com/gyaikhom/fcm

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

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

2016-11-02T12:38:32Z

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

{{algorithm
| name = Нечеткий алгоритм C средних
| serial_complexity = <math>O(C*C*K*I)</math>., где <math>I</math> - количество итераций
| input_data = <math>K*N</math>, [количество векторов * размерность]
| output_data = <math>C*K</math>, [элементы матрицы принадлежности]
| pf_height = <math>3I</math>
| pf_width = <math>C*C*K</math>
}}

Авторы : [[Участник:Protsenko|Мария Проценко]] (1.5-1.8, 2.7), [[Участник:ADovganich|Андрей Довганич]] (1.1-1.4, 1.9, 1.10)

= Свойства и структура алгоритмов =
== Общее описание алгоритма ==
Нечеткий алгоритм C-средних (fuzzy C-means) позволяет разбить имеющееся множество векторов (точек) мощностью <math>K</math> на заданное число нечетких множеств. Предназначен для кластеризации больших наборов данных. Основным достоинством алгоритма является нечеткость при определении объекта в кластер. Благодаря этому становится возможным определить объекты, которые находятся на границе, в кластеры. Из основного достоинства следует и главный недостаток - неопределенность с объектами, удаленными от центров всех кластеров. В остальном ему присущи стандартные проблемы подобного класса алгоритмов: вычислительная сложность, необходимость задания количества кластеров<ref>Нейский И.М. Классификация и сравнение методов кластеризации</ref>.

Алгоритм был разработан J.C. Dunn в 1973 г.<ref> Dunn, J. C. (1973-01-01). "A Fuzzy Relative of the ISODATA Process and Its Use in Detecting Compact Well-Separated Clusters". Journal of Cybernetics. 3 (3): 32–57. doi:10.1080/01969727308546046. ISSN 0022-0280.</ref>, усовершенствован J.C. Bezdek в 1981 г.<ref> Bezdek, James C. (1981). Pattern Recognition with Fuzzy Objective Function Algorithms. ISBN 0-306-40671-3.</ref>.

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

В общем виде алгоритм можно записать следующим образом:

# Инициализировать матрицу принадлежности;
# Вычислить центры кластеров;
# Вычислить значение решающей функции. Если значение ниже некоторого порогового или его улучшение по сравнению с предыдущей итерацией меньше определенной величины, то остановить вычисления;
# Иначе вычислить новые значения матрицы принадлежности;
# Перейти к шагу 2

== Математическое описание алгоритма ==
Рассмотрим матрицу <math> M = m_{ik} \in[0,1],\; i = 1, ..., c, \; k = 1, ..., K </math>. <math>m_{i,k}</math> - вероятность принадлежности объекта <math>k</math> к кластеру <math>i</math>; <math>c</math> - количество кластеров, <math>K</math> - количество векторов. При этом элементы матрицы удовлетворяют следующим условиям:

* сумма элементов в каждом столбце равна <math>1</math>;

* сумма всех элементов матрицы равно <math>K</math>;

Назовем <math> M </math> матрицей принадлежности.

Пусть <math>c_{i} (i = 1,2,...c)</math> - центры кластеров. Тогда рассмотрим функцию

<math>
\begin{align}
J(M, c_{1}, c_{2},...c_{c}) = \sum_{i = 1}^{c}{J_{i}} = \sum_{i = 1}^{c}\sum_{k = 1}^{K}{m_{ik}^q}d_{ik}^2 ~(1)
\end{align}
</math>

где <math> d_{ik} = \left\Vert{u_{k}-c_{i}}\right\| </math> - Евклидово расстояние между центром кластера и объектом, <math> 1 \le q \le \infty </math> - экспоненциальный весовой коэффициент, характеризующий нечеткость. Будем минимизировать значение функции <math> J </math>. Для этого вычислим центры кластеров по формуле <math> ~(2) </math>.

<math>c_{i} = {{\sum_{k = 1}^{K}{m_{ik}^q} * u_{k}} \over {\sum_{k = 1}^{K}{m_{ik}^q}}}~(2)</math>

где <math>m_{ik}</math> — коэффициент принадлежности <math>u_{k}</math> вектора к кластеру <math>c_{i}</math>

и новые значения матрицы <math> M </math> по формуле <math> ~(3) </math>

<math>m_{ik} = {1 \over \sum_{j = 1}^{c}{({{d_{ik}} \over {d_{jk}}})}^{2 \over q-1}} ~(3)</math>

<math> ~(2) </math> и <math> ~(3) </math>являются необходимым условиями достижения минимума функцией <math> J </math>. Таким образом эти два условия дают нам итерационный процесс.

Полностью алгоритм можно записать следующим образом:

# Инициализировать матрицу принадлежности <math> M </math> случайными значениями от 0 до 1;
# Вычислить центры кластеров <math>c_{i} (i = 1,2,...c)</math> используя формулу <math>~(2)</math>;
# Вычислить значение решающей функции по формуле <math>~(1)</math>. Если значение <math> J < \varepsilon,~\varepsilon > 0</math> или <math> |J_{i} - J_{i-1}| < \delta,~\delta > 0 </math>, то остановить вычисления;
# Иначе вычислить новые значения матрицы М по формуле <math>~(3)</math>;
# Перейти к шагу 2

== Вычислительное ядро алгоритма ==
Вычислительным ядром алгоритма являются формулы: <math> (1) </math>, <math> (2) </math>, <math> (3) </math>. В них производится вычисление новых центров кластеров, значения решающей функции и пересчет элементов матрицы принадлежности.

== Макроструктура алгоритма ==
Макроструктура алгоритма состоит из следующих шагов:

# Инициализация матрицы <math> M </math> случайными значениями от 0 до 1;
# Вычисление центров кластеров;
# Вычисление значения решающей функции(если оно удовлетворяет условиям останова - завершение вычислений);
# Вычисление новых элементов матрицы принадлежности;
# Переход к шагу 2;

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

Пример реализации алгоритма на языке С++. Сначала вычислим центры кластеров, потом вычислим решающую функцию, с ее помощью определим необходимость продолжать алгоритм, и при необходимости вычислим новые значения матрицы M.
<source lang="C++">

float ** m;
int *c;
int number_clusters, number_items;
m = gen_random_clusters();//заполним матрицу m случайными значениями от 0 до 1

while (true)
{
//вычисление центров кластеров
for (int i=0; i<number_clusters; i++)
{
numerator==denumerator=0;
for (int k=0; k<number_items; k++)
{
numerator+=pow(m[i, k], q)*u[k];//u[k]-вектор
denumerator+=pow(m[i, k], q);
}
c[i]= numerator / denumerator;//центры кластеров
}

j=0;//вычисление решающей функции
for (int i=0; i<number_clusters; i++)
for (int k=0; k<number_items; k++)
j+=pow(m[i, k], q)*pow(dist(c[i], x[k],2);//dist-вычисляет расстояние между заданными векторами

if ((abs(j-last_j)<delta) || (j<eps)) break;//проверка на необходимость завернешения алгоритма
last_j=j;
//обновление матрицы m
for (int i=0; i<number_clusters; i++)
for (int k=0; k<number_items; k++)
{
m[i,k]=0
for(int j=0; j<number_clusters; j++)
m[i,k]+=pow(dist(c[i], x[k])/dist(c[j], x[k]),2/(q-1));
m[i,k]=1/m[i,k];
}

}
</source>

== Последовательная сложность алгоритма ==
Каждая итерация включает в себя
* Вычисление центров кластеров <math>O(C*K)</math>
* Вычисление решающей функции <math>O(C*K)</math>
* Обновлене матрицы <math>M</math> <math>O(C*C*K)</math>
Общая сложность каждой итерации <math>O(C*C*K)</math>.

Сложность всего алгоритма будет зависеть от числа итераций, которое зависит от
* Выбора начального приближения
* Выбора условий останова

Окончательно, сложность алгоритма будет равна произведению количества итераций на их сложность

== Информационный граф ==
'''Первый ярус''' состоит из <math>C</math> параллельных операций, каждая их которых в свою очередь состоит из <math>K</math> параллельных операций, и одной, которая выполняется с использованием результата предыдущих.
Результатом работы этого яруса являются значения центров кластеров , которые будут использоваться на следующем ярусе.

'''Второй ярус''' содержит в себе <math>C*K</math> параллельных операций.
Результатом его работы является значение решающей функции <math>J</math>. Её значение определяет необходимость завершения алгоритма.

'''Третий ярус''' включает <math>C*K</math> параллельных операций, каждая из которых состоит из <math>C</math> параллельных операций, и одной, которая выполняется с использованием результата предыдущих.

[[Файл:Суперпрак.png|1200px|thumb|center|Информационный граф алгоритма. Салатовым цветом обозначены вершины графа-операции. Дугами обозначена передача информации, передаваемые данные надписаны сверху.]]

== Ресурс параллелизма алгоритма ==
На каждом шаге алгоритма необходимо вычислять сумму элементов массивов. Сложность ее вычисления на первом шаге (вычисление центров кластеров) при параллельной реализации составляет <math>O(\log_{2} C)</math>. Для каждого элемента из набора входных данных(<math> K </math>), но здесь возможен независимый расчет(координатный параллелизм). На втором шаге(вычисление решающей функции) сложность будет <math>O(\log_{2} {C*K})</math>, потому что здесь необходимо сложение всех элементов. На третьем шаге имеем сложность <math>O(\log_{2} C^2)</math>. Итого суммарная сложность итерации: <math>O(\log_{2} {C*K} + \log_{2} C^3)</math>. Воспользовавшись свойствами логарифма произведения получаем: <math>O(\log_{2} {K} + \log_{2} C^4)</math>.

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

== Входные и выходные данные алгоритма ==
Входные данные:
* <math>u_{k} ~k = 1, ..., K</math> - набор входных векторов размерности <math> N </math>;
* <math>C</math> - количество кластеров;
* <math>q</math> - экспоненциальный весовой коэффициент, характеризующий нечеткость;
* <math>\varepsilon > 0, ~\delta > 0</math> - коэффициенты, описывающие точность алгоритма.
Объем входных данных: <math> K*N </math>

Выходные данные:
* <math> M </math> - матрица принадлежности.
Объем выходных данных: <math> C*K </math>

== Свойства алгоритма ==
*Соотношение последовательной и параллельной сложности алгоритма: <math>C*C*K \over {\log_{2} {K} + \log_{2} C^4}</math>. Соответственно при распараллеливании наибольший прирост в производительности мы получим при разбиении большого набора данных на большее число кластеров;
*Вычислительная мощность: <math>{{C^2*K} \over {C*K}} = C</math>. Получается, что на чем большее количество кластеров мы разбиваем набор данных, тем менее затратным становится перемещение данных;
*Алгоритм не является устойчивым, как и другие подобные алгоритмы этого класса(например k-means). Очень многое зависит как от входных данных, так и от изначальных параметров приближения(заполнения матрицы принадлежности => исходных центров кластеров);
*Не является детерминированным. Так же очень многое зависит как от входных данных, так и от изначальных параметров приближения(заполнения матрицы принадлежности => исходных центров кластеров);
*Алгоритм не сбалансирован - доминирует операция умножения. Параллельные ветви алгоритма сбалансированы;
*Степень исхода вершины информационного графа - 2.

= Программная реализация алгоритма =
== Особенности реализации последовательного алгоритма ==
== Локальность данных и вычислений ==
== Возможные способы и особенности параллельной реализации алгоритма ==
== Масштабируемость алгоритма и его реализации ==
== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Можно найти следующие реализации алгоритма
* Для MATLAB http://www.mathworks.com/help/fuzzy/fcm.html
* В PostgreSQL http://num-meth.srcc.msu.ru/zhurnal/tom_2012/v13r207.html
Так же готовые реализации алгоритма и его описание можно найти на сайтах
* https://habrahabr.ru/post/208496/
* http://pythonhosted.org/scikit-fuzzy/auto_examples/plot_cmeans.html
* http://www.codeproject.com/Articles/91675/Computer-Vision-Applications-with-C-Fuzzy-C-means
* https://github.com/gyaikhom/fcm

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

Файл:Суперпрак.png

2016-11-02T12:38:05Z

Protsenko:

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

2016-11-02T12:36:14Z

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

{{algorithm
| name = Нечеткий алгоритм C средних
| serial_complexity = <math>O(C*C*K*I)</math>., где <math>I</math> - количество итераций
| input_data = <math>K*N</math>, [количество векторов * размерность]
| output_data = <math>C*K</math>, [элементы матрицы принадлежности]
| pf_height = <math>3I</math>
| pf_width = <math>C*C*K</math>
}}

Авторы : [[Участник:Protsenko|Мария Проценко]] (1.5-1.8, 2.7), [[Участник:ADovganich|Андрей Довганич]] (1.1-1.4, 1.9, 1.10)

= Свойства и структура алгоритмов =
== Общее описание алгоритма ==
Нечеткий алгоритм C-средних (fuzzy C-means) позволяет разбить имеющееся множество векторов (точек) мощностью <math>K</math> на заданное число нечетких множеств. Предназначен для кластеризации больших наборов данных. Основным достоинством алгоритма является нечеткость при определении объекта в кластер. Благодаря этому становится возможным определить объекты, которые находятся на границе, в кластеры. Из основного достоинства следует и главный недостаток - неопределенность с объектами, удаленными от центров всех кластеров. В остальном ему присущи стандартные проблемы подобного класса алгоритмов: вычислительная сложность, необходимость задания количества кластеров<ref>Нейский И.М. Классификация и сравнение методов кластеризации</ref>.

Алгоритм был разработан J.C. Dunn в 1973 г.<ref> Dunn, J. C. (1973-01-01). "A Fuzzy Relative of the ISODATA Process and Its Use in Detecting Compact Well-Separated Clusters". Journal of Cybernetics. 3 (3): 32–57. doi:10.1080/01969727308546046. ISSN 0022-0280.</ref>, усовершенствован J.C. Bezdek в 1981 г.<ref> Bezdek, James C. (1981). Pattern Recognition with Fuzzy Objective Function Algorithms. ISBN 0-306-40671-3.</ref>.

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

В общем виде алгоритм можно записать следующим образом:

# Инициализировать матрицу принадлежности;
# Вычислить центры кластеров;
# Вычислить значение решающей функции. Если значение ниже некоторого порогового или его улучшение по сравнению с предыдущей итерацией меньше определенной величины, то остановить вычисления;
# Иначе вычислить новые значения матрицы принадлежности;
# Перейти к шагу 2

== Математическое описание алгоритма ==
Рассмотрим матрицу <math> M = m_{ik} \in[0,1],\; i = 1, ..., c, \; k = 1, ..., K </math>. <math>m_{i,k}</math> - вероятность принадлежности объекта <math>k</math> к кластеру <math>i</math>; <math>c</math> - количество кластеров, <math>K</math> - количество векторов. При этом элементы матрицы удовлетворяют следующим условиям:

* сумма элементов в каждом столбце равна <math>1</math>;

* сумма всех элементов матрицы равно <math>K</math>;

Назовем <math> M </math> матрицей принадлежности.

Пусть <math>c_{i} (i = 1,2,...c)</math> - центры кластеров. Тогда рассмотрим функцию

<math>
\begin{align}
J(M, c_{1}, c_{2},...c_{c}) = \sum_{i = 1}^{c}{J_{i}} = \sum_{i = 1}^{c}\sum_{k = 1}^{K}{m_{ik}^q}d_{ik}^2 ~(1)
\end{align}
</math>

где <math> d_{ik} = \left\Vert{u_{k}-c_{i}}\right\| </math> - Евклидово расстояние между центром кластера и объектом, <math> 1 \le q \le \infty </math> - экспоненциальный весовой коэффициент, характеризующий нечеткость. Будем минимизировать значение функции <math> J </math>. Для этого вычислим центры кластеров по формуле <math> ~(2) </math>.

<math>c_{i} = {{\sum_{k = 1}^{K}{m_{ik}^q} * u_{k}} \over {\sum_{k = 1}^{K}{m_{ik}^q}}}~(2)</math>

где <math>m_{ik}</math> — коэффициент принадлежности <math>u_{k}</math> вектора к кластеру <math>c_{i}</math>

и новые значения матрицы <math> M </math> по формуле <math> ~(3) </math>

<math>m_{ik} = {1 \over \sum_{j = 1}^{c}{({{d_{ik}} \over {d_{jk}}})}^{2 \over q-1}} ~(3)</math>

<math> ~(2) </math> и <math> ~(3) </math>являются необходимым условиями достижения минимума функцией <math> J </math>. Таким образом эти два условия дают нам итерационный процесс.

Полностью алгоритм можно записать следующим образом:

# Инициализировать матрицу принадлежности <math> M </math> случайными значениями от 0 до 1;
# Вычислить центры кластеров <math>c_{i} (i = 1,2,...c)</math> используя формулу <math>~(2)</math>;
# Вычислить значение решающей функции по формуле <math>~(1)</math>. Если значение <math> J < \varepsilon,~\varepsilon > 0</math> или <math> |J_{i} - J_{i-1}| < \delta,~\delta > 0 </math>, то остановить вычисления;
# Иначе вычислить новые значения матрицы М по формуле <math>~(3)</math>;
# Перейти к шагу 2

== Вычислительное ядро алгоритма ==
Вычислительным ядром алгоритма являются формулы: <math> (1) </math>, <math> (2) </math>, <math> (3) </math>. В них производится вычисление новых центров кластеров, значения решающей функции и пересчет элементов матрицы принадлежности.

== Макроструктура алгоритма ==
Макроструктура алгоритма состоит из следующих шагов:

# Инициализация матрицы <math> M </math> случайными значениями от 0 до 1;
# Вычисление центров кластеров;
# Вычисление значения решающей функции(если оно удовлетворяет условиям останова - завершение вычислений);
# Вычисление новых элементов матрицы принадлежности;
# Переход к шагу 2;

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

Пример реализации алгоритма на языке С++. Сначала вычислим центры кластеров, потом вычислим решающую функцию, с ее помощью определим необходимость продолжать алгоритм, и при необходимости вычислим новые значения матрицы M.
<source lang="C++">

float ** m;
int *c;
int number_clusters, number_items;
m = gen_random_clusters();//заполним матрицу m случайными значениями от 0 до 1

while (true)
{
//вычисление центров кластеров
for (int i=0; i<number_clusters; i++)
{
numerator==denumerator=0;
for (int k=0; k<number_items; k++)
{
numerator+=pow(m[i, k], q)*u[k];//u[k]-вектор
denumerator+=pow(m[i, k], q);
}
c[i]= numerator / denumerator;//центры кластеров
}

j=0;//вычисление решающей функции
for (int i=0; i<number_clusters; i++)
for (int k=0; k<number_items; k++)
j+=pow(m[i, k], q)*pow(dist(c[i], x[k],2);//dist-вычисляет расстояние между заданными векторами

if ((abs(j-last_j)<delta) || (j<eps)) break;//проверка на необходимость завернешения алгоритма
last_j=j;
//обновление матрицы m
for (int i=0; i<number_clusters; i++)
for (int k=0; k<number_items; k++)
{
m[i,k]=0
for(int j=0; j<number_clusters; j++)
m[i,k]+=pow(dist(c[i], x[k])/dist(c[j], x[k]),2/(q-1));
m[i,k]=1/m[i,k];
}

}
</source>

== Последовательная сложность алгоритма ==
Каждая итерация включает в себя
* Вычисление центров кластеров <math>O(C*K)</math>
* Вычисление решающей функции <math>O(C*K)</math>
* Обновлене матрицы <math>M</math> <math>O(C*C*K)</math>
Общая сложность каждой итерации <math>O(C*C*K)</math>.

Сложность всего алгоритма будет зависеть от числа итераций, которое зависит от
* Выбора начального приближения
* Выбора условий останова

Окончательно, сложность алгоритма будет равна произведению количества итераций на их сложность

== Информационный граф ==
'''Первый ярус''' состоит из <math>C</math> параллельных операций, каждая их которых в свою очередь состоит из <math>K</math> параллельных операций, и одной, которая выполняется с использованием результата предыдущих.
Результатом работы этого яруса являются значения центров кластеров , которые будут использоваться на следующем ярусе.

'''Второй ярус''' содержит в себе <math>C*K</math> параллельных операций.
Результатом его работы является значение решающей функции <math>J</math>. Её значение определяет необходимость завершения алгоритма.

'''Третий ярус''' включает <math>C*K</math> параллельных операций, каждая из которых состоит из <math>C</math> параллельных операций, и одной, которая выполняется с использованием результата предыдущих.

[[Файл:Суперпрак.jpg|1200px|thumb|center|Информационный граф алгоритма. Салатовым цветом обозначены вершины графа-операции. Дугами обозначена передача информации, передаваемые данные надписаны сверху.]]

== Ресурс параллелизма алгоритма ==
На каждом шаге алгоритма необходимо вычислять сумму элементов массивов. Сложность ее вычисления на первом шаге (вычисление центров кластеров) при параллельной реализации составляет <math>O(\log_{2} C)</math>. Для каждого элемента из набора входных данных(<math> K </math>), но здесь возможен независимый расчет(координатный параллелизм). На втором шаге(вычисление решающей функции) сложность будет <math>O(\log_{2} {C*K})</math>, потому что здесь необходимо сложение всех элементов. На третьем шаге имеем сложность <math>O(\log_{2} C^2)</math>. Итого суммарная сложность итерации: <math>O(\log_{2} {C*K} + \log_{2} C^3)</math>. Воспользовавшись свойствами логарифма произведения получаем: <math>O(\log_{2} {K} + \log_{2} C^4)</math>.

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

== Входные и выходные данные алгоритма ==
Входные данные:
* <math>u_{k} ~k = 1, ..., K</math> - набор входных векторов размерности <math> N </math>;
* <math>C</math> - количество кластеров;
* <math>q</math> - экспоненциальный весовой коэффициент, характеризующий нечеткость;
* <math>\varepsilon > 0, ~\delta > 0</math> - коэффициенты, описывающие точность алгоритма.
Объем входных данных: <math> K*N </math>

Выходные данные:
* <math> M </math> - матрица принадлежности.
Объем выходных данных: <math> C*K </math>

== Свойства алгоритма ==
*Соотношение последовательной и параллельной сложности алгоритма: <math>C*C*K \over {\log_{2} {K} + \log_{2} C^4}</math>. Соответственно при распараллеливании наибольший прирост в производительности мы получим при разбиении большого набора данных на большее число кластеров;
*Вычислительная мощность: <math>{{C^2*K} \over {C*K}} = C</math>. Получается, что на чем большее количество кластеров мы разбиваем набор данных, тем менее затратным становится перемещение данных;
*Алгоритм не является устойчивым, как и другие подобные алгоритмы этого класса(например k-means). Очень многое зависит как от входных данных, так и от изначальных параметров приближения(заполнения матрицы принадлежности => исходных центров кластеров);
*Не является детерминированным. Так же очень многое зависит как от входных данных, так и от изначальных параметров приближения(заполнения матрицы принадлежности => исходных центров кластеров);
*Алгоритм не сбалансирован - доминирует операция умножения. Параллельные ветви алгоритма сбалансированы;
*Степень исхода вершины информационного графа - 2.

= Программная реализация алгоритма =
== Особенности реализации последовательного алгоритма ==
== Локальность данных и вычислений ==
== Возможные способы и особенности параллельной реализации алгоритма ==
== Масштабируемость алгоритма и его реализации ==
== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Можно найти следующие реализации алгоритма
* Для MATLAB http://www.mathworks.com/help/fuzzy/fcm.html
* В PostgreSQL http://num-meth.srcc.msu.ru/zhurnal/tom_2012/v13r207.html
Так же готовые реализации алгоритма и его описание можно найти на сайтах
* https://habrahabr.ru/post/208496/
* http://pythonhosted.org/scikit-fuzzy/auto_examples/plot_cmeans.html
* http://www.codeproject.com/Articles/91675/Computer-Vision-Applications-with-C-Fuzzy-C-means
* https://github.com/gyaikhom/fcm

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

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

2016-11-02T12:36:00Z

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

{{algorithm
| name = Нечеткий алгоритм C средних
| serial_complexity = <math>O(C*C*K*I)</math>., где <math>I</math> - количество итераций
| input_data = <math>K*N</math>, [количество векторов * размерность]
| output_data = <math>C*K</math>, [элементы матрицы принадлежности]
| pf_height = <math>3I</math>
| pf_width = <math>C*C*K</math>
}}

Авторы : [[Участник:Protsenko|Мария Проценко]] (1.5-1.8, 2.7), [[Участник:ADovganich|Андрей Довганич]] (1.1-1.4, 1.9, 1.10)

= Свойства и структура алгоритмов =
== Общее описание алгоритма ==
Нечеткий алгоритм C-средних (fuzzy C-means) позволяет разбить имеющееся множество векторов (точек) мощностью <math>K</math> на заданное число нечетких множеств. Предназначен для кластеризации больших наборов данных. Основным достоинством алгоритма является нечеткость при определении объекта в кластер. Благодаря этому становится возможным определить объекты, которые находятся на границе, в кластеры. Из основного достоинства следует и главный недостаток - неопределенность с объектами, удаленными от центров всех кластеров. В остальном ему присущи стандартные проблемы подобного класса алгоритмов: вычислительная сложность, необходимость задания количества кластеров<ref>Нейский И.М. Классификация и сравнение методов кластеризации</ref>.

Алгоритм был разработан J.C. Dunn в 1973 г.<ref> Dunn, J. C. (1973-01-01). "A Fuzzy Relative of the ISODATA Process and Its Use in Detecting Compact Well-Separated Clusters". Journal of Cybernetics. 3 (3): 32–57. doi:10.1080/01969727308546046. ISSN 0022-0280.</ref>, усовершенствован J.C. Bezdek в 1981 г.<ref> Bezdek, James C. (1981). Pattern Recognition with Fuzzy Objective Function Algorithms. ISBN 0-306-40671-3.</ref>.

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

В общем виде алгоритм можно записать следующим образом:

# Инициализировать матрицу принадлежности;
# Вычислить центры кластеров;
# Вычислить значение решающей функции. Если значение ниже некоторого порогового или его улучшение по сравнению с предыдущей итерацией меньше определенной величины, то остановить вычисления;
# Иначе вычислить новые значения матрицы принадлежности;
# Перейти к шагу 2

== Математическое описание алгоритма ==
Рассмотрим матрицу <math> M = m_{ik} \in[0,1],\; i = 1, ..., c, \; k = 1, ..., K </math>. <math>m_{i,k}</math> - вероятность принадлежности объекта <math>k</math> к кластеру <math>i</math>; <math>c</math> - количество кластеров, <math>K</math> - количество векторов. При этом элементы матрицы удовлетворяют следующим условиям:

* сумма элементов в каждом столбце равна <math>1</math>;

* сумма всех элементов матрицы равно <math>K</math>;

Назовем <math> M </math> матрицей принадлежности.

Пусть <math>c_{i} (i = 1,2,...c)</math> - центры кластеров. Тогда рассмотрим функцию

<math>
\begin{align}
J(M, c_{1}, c_{2},...c_{c}) = \sum_{i = 1}^{c}{J_{i}} = \sum_{i = 1}^{c}\sum_{k = 1}^{K}{m_{ik}^q}d_{ik}^2 ~(1)
\end{align}
</math>

где <math> d_{ik} = \left\Vert{u_{k}-c_{i}}\right\| </math> - Евклидово расстояние между центром кластера и объектом, <math> 1 \le q \le \infty </math> - экспоненциальный весовой коэффициент, характеризующий нечеткость. Будем минимизировать значение функции <math> J </math>. Для этого вычислим центры кластеров по формуле <math> ~(2) </math>.

<math>c_{i} = {{\sum_{k = 1}^{K}{m_{ik}^q} * u_{k}} \over {\sum_{k = 1}^{K}{m_{ik}^q}}}~(2)</math>

где <math>m_{ik}</math> — коэффициент принадлежности <math>u_{k}</math> вектора к кластеру <math>c_{i}</math>

и новые значения матрицы <math> M </math> по формуле <math> ~(3) </math>

<math>m_{ik} = {1 \over \sum_{j = 1}^{c}{({{d_{ik}} \over {d_{jk}}})}^{2 \over q-1}} ~(3)</math>

<math> ~(2) </math> и <math> ~(3) </math>являются необходимым условиями достижения минимума функцией <math> J </math>. Таким образом эти два условия дают нам итерационный процесс.

Полностью алгоритм можно записать следующим образом:

# Инициализировать матрицу принадлежности <math> M </math> случайными значениями от 0 до 1;
# Вычислить центры кластеров <math>c_{i} (i = 1,2,...c)</math> используя формулу <math>~(2)</math>;
# Вычислить значение решающей функции по формуле <math>~(1)</math>. Если значение <math> J < \varepsilon,~\varepsilon > 0</math> или <math> |J_{i} - J_{i-1}| < \delta,~\delta > 0 </math>, то остановить вычисления;
# Иначе вычислить новые значения матрицы М по формуле <math>~(3)</math>;
# Перейти к шагу 2

== Вычислительное ядро алгоритма ==
Вычислительным ядром алгоритма являются формулы: <math> (1) </math>, <math> (2) </math>, <math> (3) </math>. В них производится вычисление новых центров кластеров, значения решающей функции и пересчет элементов матрицы принадлежности.

== Макроструктура алгоритма ==
Макроструктура алгоритма состоит из следующих шагов:

# Инициализация матрицы <math> M </math> случайными значениями от 0 до 1;
# Вычисление центров кластеров;
# Вычисление значения решающей функции(если оно удовлетворяет условиям останова - завершение вычислений);
# Вычисление новых элементов матрицы принадлежности;
# Переход к шагу 2;

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

Пример реализации алгоритма на языке С++. Сначала вычислим центры кластеров, потом вычислим решающую функцию, с ее помощью определим необходимость продолжать алгоритм, и при необходимости вычислим новые значения матрицы M.
<source lang="C++">

float ** m;
int *c;
int number_clusters, number_items;
m = gen_random_clusters();//заполним матрицу m случайными значениями от 0 до 1

while (true)
{
//вычисление центров кластеров
for (int i=0; i<number_clusters; i++)
{
numerator==denumerator=0;
for (int k=0; k<number_items; k++)
{
numerator+=pow(m[i, k], q)*u[k];//u[k]-вектор
denumerator+=pow(m[i, k], q);
}
c[i]= numerator / denumerator;//центры кластеров
}

j=0;//вычисление решающей функции
for (int i=0; i<number_clusters; i++)
for (int k=0; k<number_items; k++)
j+=pow(m[i, k], q)*pow(dist(c[i], x[k],2);//dist-вычисляет расстояние между заданными векторами

if ((abs(j-last_j)<delta) || (j<eps)) break;//проверка на необходимость завернешения алгоритма
last_j=j;
//обновление матрицы m
for (int i=0; i<number_clusters; i++)
for (int k=0; k<number_items; k++)
{
m[i,k]=0
for(int j=0; j<number_clusters; j++)
m[i,k]+=pow(dist(c[i], x[k])/dist(c[j], x[k]),2/(q-1));
m[i,k]=1/m[i,k];
}

}
</source>

== Последовательная сложность алгоритма ==
Каждая итерация включает в себя
* Вычисление центров кластеров <math>O(C*K)</math>
* Вычисление решающей функции <math>O(C*K)</math>
* Обновлене матрицы <math>M</math> <math>O(C*C*K)</math>
Общая сложность каждой итерации <math>O(C*C*K)</math>.

Сложность всего алгоритма будет зависеть от числа итераций, которое зависит от
* Выбора начального приближения
* Выбора условий останова

Окончательно, сложность алгоритма будет равна произведению количества итераций на их сложность

== Информационный граф ==
'''Первый ярус''' состоит из <math>C</math> параллельных операций, каждая их которых в свою очередь состоит из <math>K</math> параллельных операций, и одной, которая выполняется с использованием результата предыдущих.
Результатом работы этого яруса являются значения центров кластеров , которые будут использоваться на следующем ярусе.

'''Второй ярус''' содержит в себе <math>C*K</math> параллельных операций.
Результатом его работы является значение решающей функции <math>J</math>. Её значение определяет необходимость завершения алгоритма.

'''Третий ярус''' включает <math>C*K</math> параллельных операций, каждая из которых состоит из <math>C</math> параллельных операций, и одной, которая выполняется с использованием результата предыдущих.

[[Файл:Суперпрак.jpg|1000px|thumb|center|Информационный граф алгоритма. Салатовым цветом обозначены вершины графа-операции. Дугами обозначена передача информации, передаваемые данные надписаны сверху.]]

== Ресурс параллелизма алгоритма ==
На каждом шаге алгоритма необходимо вычислять сумму элементов массивов. Сложность ее вычисления на первом шаге (вычисление центров кластеров) при параллельной реализации составляет <math>O(\log_{2} C)</math>. Для каждого элемента из набора входных данных(<math> K </math>), но здесь возможен независимый расчет(координатный параллелизм). На втором шаге(вычисление решающей функции) сложность будет <math>O(\log_{2} {C*K})</math>, потому что здесь необходимо сложение всех элементов. На третьем шаге имеем сложность <math>O(\log_{2} C^2)</math>. Итого суммарная сложность итерации: <math>O(\log_{2} {C*K} + \log_{2} C^3)</math>. Воспользовавшись свойствами логарифма произведения получаем: <math>O(\log_{2} {K} + \log_{2} C^4)</math>.

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

== Входные и выходные данные алгоритма ==
Входные данные:
* <math>u_{k} ~k = 1, ..., K</math> - набор входных векторов размерности <math> N </math>;
* <math>C</math> - количество кластеров;
* <math>q</math> - экспоненциальный весовой коэффициент, характеризующий нечеткость;
* <math>\varepsilon > 0, ~\delta > 0</math> - коэффициенты, описывающие точность алгоритма.
Объем входных данных: <math> K*N </math>

Выходные данные:
* <math> M </math> - матрица принадлежности.
Объем выходных данных: <math> C*K </math>

== Свойства алгоритма ==
*Соотношение последовательной и параллельной сложности алгоритма: <math>C*C*K \over {\log_{2} {K} + \log_{2} C^4}</math>. Соответственно при распараллеливании наибольший прирост в производительности мы получим при разбиении большого набора данных на большее число кластеров;
*Вычислительная мощность: <math>{{C^2*K} \over {C*K}} = C</math>. Получается, что на чем большее количество кластеров мы разбиваем набор данных, тем менее затратным становится перемещение данных;
*Алгоритм не является устойчивым, как и другие подобные алгоритмы этого класса(например k-means). Очень многое зависит как от входных данных, так и от изначальных параметров приближения(заполнения матрицы принадлежности => исходных центров кластеров);
*Не является детерминированным. Так же очень многое зависит как от входных данных, так и от изначальных параметров приближения(заполнения матрицы принадлежности => исходных центров кластеров);
*Алгоритм не сбалансирован - доминирует операция умножения. Параллельные ветви алгоритма сбалансированы;
*Степень исхода вершины информационного графа - 2.

= Программная реализация алгоритма =
== Особенности реализации последовательного алгоритма ==
== Локальность данных и вычислений ==
== Возможные способы и особенности параллельной реализации алгоритма ==
== Масштабируемость алгоритма и его реализации ==
== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Можно найти следующие реализации алгоритма
* Для MATLAB http://www.mathworks.com/help/fuzzy/fcm.html
* В PostgreSQL http://num-meth.srcc.msu.ru/zhurnal/tom_2012/v13r207.html
Так же готовые реализации алгоритма и его описание можно найти на сайтах
* https://habrahabr.ru/post/208496/
* http://pythonhosted.org/scikit-fuzzy/auto_examples/plot_cmeans.html
* http://www.codeproject.com/Articles/91675/Computer-Vision-Applications-with-C-Fuzzy-C-means
* https://github.com/gyaikhom/fcm

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

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

2016-11-02T12:35:45Z

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

{{algorithm
| name = Нечеткий алгоритм C средних
| serial_complexity = <math>O(C*C*K*I)</math>., где <math>I</math> - количество итераций
| input_data = <math>K*N</math>, [количество векторов * размерность]
| output_data = <math>C*K</math>, [элементы матрицы принадлежности]
| pf_height = <math>3I</math>
| pf_width = <math>C*C*K</math>
}}

Авторы : [[Участник:Protsenko|Мария Проценко]] (1.5-1.8, 2.7), [[Участник:ADovganich|Андрей Довганич]] (1.1-1.4, 1.9, 1.10)

= Свойства и структура алгоритмов =
== Общее описание алгоритма ==
Нечеткий алгоритм C-средних (fuzzy C-means) позволяет разбить имеющееся множество векторов (точек) мощностью <math>K</math> на заданное число нечетких множеств. Предназначен для кластеризации больших наборов данных. Основным достоинством алгоритма является нечеткость при определении объекта в кластер. Благодаря этому становится возможным определить объекты, которые находятся на границе, в кластеры. Из основного достоинства следует и главный недостаток - неопределенность с объектами, удаленными от центров всех кластеров. В остальном ему присущи стандартные проблемы подобного класса алгоритмов: вычислительная сложность, необходимость задания количества кластеров<ref>Нейский И.М. Классификация и сравнение методов кластеризации</ref>.

Алгоритм был разработан J.C. Dunn в 1973 г.<ref> Dunn, J. C. (1973-01-01). "A Fuzzy Relative of the ISODATA Process and Its Use in Detecting Compact Well-Separated Clusters". Journal of Cybernetics. 3 (3): 32–57. doi:10.1080/01969727308546046. ISSN 0022-0280.</ref>, усовершенствован J.C. Bezdek в 1981 г.<ref> Bezdek, James C. (1981). Pattern Recognition with Fuzzy Objective Function Algorithms. ISBN 0-306-40671-3.</ref>.

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

В общем виде алгоритм можно записать следующим образом:

# Инициализировать матрицу принадлежности;
# Вычислить центры кластеров;
# Вычислить значение решающей функции. Если значение ниже некоторого порогового или его улучшение по сравнению с предыдущей итерацией меньше определенной величины, то остановить вычисления;
# Иначе вычислить новые значения матрицы принадлежности;
# Перейти к шагу 2

== Математическое описание алгоритма ==
Рассмотрим матрицу <math> M = m_{ik} \in[0,1],\; i = 1, ..., c, \; k = 1, ..., K </math>. <math>m_{i,k}</math> - вероятность принадлежности объекта <math>k</math> к кластеру <math>i</math>; <math>c</math> - количество кластеров, <math>K</math> - количество векторов. При этом элементы матрицы удовлетворяют следующим условиям:

* сумма элементов в каждом столбце равна <math>1</math>;

* сумма всех элементов матрицы равно <math>K</math>;

Назовем <math> M </math> матрицей принадлежности.

Пусть <math>c_{i} (i = 1,2,...c)</math> - центры кластеров. Тогда рассмотрим функцию

<math>
\begin{align}
J(M, c_{1}, c_{2},...c_{c}) = \sum_{i = 1}^{c}{J_{i}} = \sum_{i = 1}^{c}\sum_{k = 1}^{K}{m_{ik}^q}d_{ik}^2 ~(1)
\end{align}
</math>

где <math> d_{ik} = \left\Vert{u_{k}-c_{i}}\right\| </math> - Евклидово расстояние между центром кластера и объектом, <math> 1 \le q \le \infty </math> - экспоненциальный весовой коэффициент, характеризующий нечеткость. Будем минимизировать значение функции <math> J </math>. Для этого вычислим центры кластеров по формуле <math> ~(2) </math>.

<math>c_{i} = {{\sum_{k = 1}^{K}{m_{ik}^q} * u_{k}} \over {\sum_{k = 1}^{K}{m_{ik}^q}}}~(2)</math>

где <math>m_{ik}</math> — коэффициент принадлежности <math>u_{k}</math> вектора к кластеру <math>c_{i}</math>

и новые значения матрицы <math> M </math> по формуле <math> ~(3) </math>

<math>m_{ik} = {1 \over \sum_{j = 1}^{c}{({{d_{ik}} \over {d_{jk}}})}^{2 \over q-1}} ~(3)</math>

<math> ~(2) </math> и <math> ~(3) </math>являются необходимым условиями достижения минимума функцией <math> J </math>. Таким образом эти два условия дают нам итерационный процесс.

Полностью алгоритм можно записать следующим образом:

# Инициализировать матрицу принадлежности <math> M </math> случайными значениями от 0 до 1;
# Вычислить центры кластеров <math>c_{i} (i = 1,2,...c)</math> используя формулу <math>~(2)</math>;
# Вычислить значение решающей функции по формуле <math>~(1)</math>. Если значение <math> J < \varepsilon,~\varepsilon > 0</math> или <math> |J_{i} - J_{i-1}| < \delta,~\delta > 0 </math>, то остановить вычисления;
# Иначе вычислить новые значения матрицы М по формуле <math>~(3)</math>;
# Перейти к шагу 2

== Вычислительное ядро алгоритма ==
Вычислительным ядром алгоритма являются формулы: <math> (1) </math>, <math> (2) </math>, <math> (3) </math>. В них производится вычисление новых центров кластеров, значения решающей функции и пересчет элементов матрицы принадлежности.

== Макроструктура алгоритма ==
Макроструктура алгоритма состоит из следующих шагов:

# Инициализация матрицы <math> M </math> случайными значениями от 0 до 1;
# Вычисление центров кластеров;
# Вычисление значения решающей функции(если оно удовлетворяет условиям останова - завершение вычислений);
# Вычисление новых элементов матрицы принадлежности;
# Переход к шагу 2;

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

Пример реализации алгоритма на языке С++. Сначала вычислим центры кластеров, потом вычислим решающую функцию, с ее помощью определим необходимость продолжать алгоритм, и при необходимости вычислим новые значения матрицы M.
<source lang="C++">

float ** m;
int *c;
int number_clusters, number_items;
m = gen_random_clusters();//заполним матрицу m случайными значениями от 0 до 1

while (true)
{
//вычисление центров кластеров
for (int i=0; i<number_clusters; i++)
{
numerator==denumerator=0;
for (int k=0; k<number_items; k++)
{
numerator+=pow(m[i, k], q)*u[k];//u[k]-вектор
denumerator+=pow(m[i, k], q);
}
c[i]= numerator / denumerator;//центры кластеров
}

j=0;//вычисление решающей функции
for (int i=0; i<number_clusters; i++)
for (int k=0; k<number_items; k++)
j+=pow(m[i, k], q)*pow(dist(c[i], x[k],2);//dist-вычисляет расстояние между заданными векторами

if ((abs(j-last_j)<delta) || (j<eps)) break;//проверка на необходимость завернешения алгоритма
last_j=j;
//обновление матрицы m
for (int i=0; i<number_clusters; i++)
for (int k=0; k<number_items; k++)
{
m[i,k]=0
for(int j=0; j<number_clusters; j++)
m[i,k]+=pow(dist(c[i], x[k])/dist(c[j], x[k]),2/(q-1));
m[i,k]=1/m[i,k];
}

}
</source>

== Последовательная сложность алгоритма ==
Каждая итерация включает в себя
* Вычисление центров кластеров <math>O(C*K)</math>
* Вычисление решающей функции <math>O(C*K)</math>
* Обновлене матрицы <math>M</math> <math>O(C*C*K)</math>
Общая сложность каждой итерации <math>O(C*C*K)</math>.

Сложность всего алгоритма будет зависеть от числа итераций, которое зависит от
* Выбора начального приближения
* Выбора условий останова

Окончательно, сложность алгоритма будет равна произведению количества итераций на их сложность

== Информационный граф ==
'''Первый ярус''' состоит из <math>C</math> параллельных операций, каждая их которых в свою очередь состоит из <math>K</math> параллельных операций, и одной, которая выполняется с использованием результата предыдущих.
Результатом работы этого яруса являются значения центров кластеров , которые будут использоваться на следующем ярусе.

'''Второй ярус''' содержит в себе <math>C*K</math> параллельных операций.
Результатом его работы является значение решающей функции <math>J</math>. Её значение определяет необходимость завершения алгоритма.

'''Третий ярус''' включает <math>C*K</math> параллельных операций, каждая из которых состоит из <math>C</math> параллельных операций, и одной, которая выполняется с использованием результата предыдущих.

[[Файл:Суперпрак.jpg|thumb|center|Информационный граф алгоритма. Салатовым цветом обозначены вершины графа-операции. Дугами обозначена передача информации, передаваемые данные надписаны сверху.]]

== Ресурс параллелизма алгоритма ==
На каждом шаге алгоритма необходимо вычислять сумму элементов массивов. Сложность ее вычисления на первом шаге (вычисление центров кластеров) при параллельной реализации составляет <math>O(\log_{2} C)</math>. Для каждого элемента из набора входных данных(<math> K </math>), но здесь возможен независимый расчет(координатный параллелизм). На втором шаге(вычисление решающей функции) сложность будет <math>O(\log_{2} {C*K})</math>, потому что здесь необходимо сложение всех элементов. На третьем шаге имеем сложность <math>O(\log_{2} C^2)</math>. Итого суммарная сложность итерации: <math>O(\log_{2} {C*K} + \log_{2} C^3)</math>. Воспользовавшись свойствами логарифма произведения получаем: <math>O(\log_{2} {K} + \log_{2} C^4)</math>.

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

== Входные и выходные данные алгоритма ==
Входные данные:
* <math>u_{k} ~k = 1, ..., K</math> - набор входных векторов размерности <math> N </math>;
* <math>C</math> - количество кластеров;
* <math>q</math> - экспоненциальный весовой коэффициент, характеризующий нечеткость;
* <math>\varepsilon > 0, ~\delta > 0</math> - коэффициенты, описывающие точность алгоритма.
Объем входных данных: <math> K*N </math>

Выходные данные:
* <math> M </math> - матрица принадлежности.
Объем выходных данных: <math> C*K </math>

== Свойства алгоритма ==
*Соотношение последовательной и параллельной сложности алгоритма: <math>C*C*K \over {\log_{2} {K} + \log_{2} C^4}</math>. Соответственно при распараллеливании наибольший прирост в производительности мы получим при разбиении большого набора данных на большее число кластеров;
*Вычислительная мощность: <math>{{C^2*K} \over {C*K}} = C</math>. Получается, что на чем большее количество кластеров мы разбиваем набор данных, тем менее затратным становится перемещение данных;
*Алгоритм не является устойчивым, как и другие подобные алгоритмы этого класса(например k-means). Очень многое зависит как от входных данных, так и от изначальных параметров приближения(заполнения матрицы принадлежности => исходных центров кластеров);
*Не является детерминированным. Так же очень многое зависит как от входных данных, так и от изначальных параметров приближения(заполнения матрицы принадлежности => исходных центров кластеров);
*Алгоритм не сбалансирован - доминирует операция умножения. Параллельные ветви алгоритма сбалансированы;
*Степень исхода вершины информационного графа - 2.

= Программная реализация алгоритма =
== Особенности реализации последовательного алгоритма ==
== Локальность данных и вычислений ==
== Возможные способы и особенности параллельной реализации алгоритма ==
== Масштабируемость алгоритма и его реализации ==
== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Можно найти следующие реализации алгоритма
* Для MATLAB http://www.mathworks.com/help/fuzzy/fcm.html
* В PostgreSQL http://num-meth.srcc.msu.ru/zhurnal/tom_2012/v13r207.html
Так же готовые реализации алгоритма и его описание можно найти на сайтах
* https://habrahabr.ru/post/208496/
* http://pythonhosted.org/scikit-fuzzy/auto_examples/plot_cmeans.html
* http://www.codeproject.com/Articles/91675/Computer-Vision-Applications-with-C-Fuzzy-C-means
* https://github.com/gyaikhom/fcm

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

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

2016-11-02T12:35:31Z

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

{{algorithm
| name = Нечеткий алгоритм C средних
| serial_complexity = <math>O(C*C*K*I)</math>., где <math>I</math> - количество итераций
| input_data = <math>K*N</math>, [количество векторов * размерность]
| output_data = <math>C*K</math>, [элементы матрицы принадлежности]
| pf_height = <math>3I</math>
| pf_width = <math>C*C*K</math>
}}

Авторы : [[Участник:Protsenko|Мария Проценко]] (1.5-1.8, 2.7), [[Участник:ADovganich|Андрей Довганич]] (1.1-1.4, 1.9, 1.10)

= Свойства и структура алгоритмов =
== Общее описание алгоритма ==
Нечеткий алгоритм C-средних (fuzzy C-means) позволяет разбить имеющееся множество векторов (точек) мощностью <math>K</math> на заданное число нечетких множеств. Предназначен для кластеризации больших наборов данных. Основным достоинством алгоритма является нечеткость при определении объекта в кластер. Благодаря этому становится возможным определить объекты, которые находятся на границе, в кластеры. Из основного достоинства следует и главный недостаток - неопределенность с объектами, удаленными от центров всех кластеров. В остальном ему присущи стандартные проблемы подобного класса алгоритмов: вычислительная сложность, необходимость задания количества кластеров<ref>Нейский И.М. Классификация и сравнение методов кластеризации</ref>.

Алгоритм был разработан J.C. Dunn в 1973 г.<ref> Dunn, J. C. (1973-01-01). "A Fuzzy Relative of the ISODATA Process and Its Use in Detecting Compact Well-Separated Clusters". Journal of Cybernetics. 3 (3): 32–57. doi:10.1080/01969727308546046. ISSN 0022-0280.</ref>, усовершенствован J.C. Bezdek в 1981 г.<ref> Bezdek, James C. (1981). Pattern Recognition with Fuzzy Objective Function Algorithms. ISBN 0-306-40671-3.</ref>.

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

В общем виде алгоритм можно записать следующим образом:

# Инициализировать матрицу принадлежности;
# Вычислить центры кластеров;
# Вычислить значение решающей функции. Если значение ниже некоторого порогового или его улучшение по сравнению с предыдущей итерацией меньше определенной величины, то остановить вычисления;
# Иначе вычислить новые значения матрицы принадлежности;
# Перейти к шагу 2

== Математическое описание алгоритма ==
Рассмотрим матрицу <math> M = m_{ik} \in[0,1],\; i = 1, ..., c, \; k = 1, ..., K </math>. <math>m_{i,k}</math> - вероятность принадлежности объекта <math>k</math> к кластеру <math>i</math>; <math>c</math> - количество кластеров, <math>K</math> - количество векторов. При этом элементы матрицы удовлетворяют следующим условиям:

* сумма элементов в каждом столбце равна <math>1</math>;

* сумма всех элементов матрицы равно <math>K</math>;

Назовем <math> M </math> матрицей принадлежности.

Пусть <math>c_{i} (i = 1,2,...c)</math> - центры кластеров. Тогда рассмотрим функцию

<math>
\begin{align}
J(M, c_{1}, c_{2},...c_{c}) = \sum_{i = 1}^{c}{J_{i}} = \sum_{i = 1}^{c}\sum_{k = 1}^{K}{m_{ik}^q}d_{ik}^2 ~(1)
\end{align}
</math>

где <math> d_{ik} = \left\Vert{u_{k}-c_{i}}\right\| </math> - Евклидово расстояние между центром кластера и объектом, <math> 1 \le q \le \infty </math> - экспоненциальный весовой коэффициент, характеризующий нечеткость. Будем минимизировать значение функции <math> J </math>. Для этого вычислим центры кластеров по формуле <math> ~(2) </math>.

<math>c_{i} = {{\sum_{k = 1}^{K}{m_{ik}^q} * u_{k}} \over {\sum_{k = 1}^{K}{m_{ik}^q}}}~(2)</math>

где <math>m_{ik}</math> — коэффициент принадлежности <math>u_{k}</math> вектора к кластеру <math>c_{i}</math>

и новые значения матрицы <math> M </math> по формуле <math> ~(3) </math>

<math>m_{ik} = {1 \over \sum_{j = 1}^{c}{({{d_{ik}} \over {d_{jk}}})}^{2 \over q-1}} ~(3)</math>

<math> ~(2) </math> и <math> ~(3) </math>являются необходимым условиями достижения минимума функцией <math> J </math>. Таким образом эти два условия дают нам итерационный процесс.

Полностью алгоритм можно записать следующим образом:

# Инициализировать матрицу принадлежности <math> M </math> случайными значениями от 0 до 1;
# Вычислить центры кластеров <math>c_{i} (i = 1,2,...c)</math> используя формулу <math>~(2)</math>;
# Вычислить значение решающей функции по формуле <math>~(1)</math>. Если значение <math> J < \varepsilon,~\varepsilon > 0</math> или <math> |J_{i} - J_{i-1}| < \delta,~\delta > 0 </math>, то остановить вычисления;
# Иначе вычислить новые значения матрицы М по формуле <math>~(3)</math>;
# Перейти к шагу 2

== Вычислительное ядро алгоритма ==
Вычислительным ядром алгоритма являются формулы: <math> (1) </math>, <math> (2) </math>, <math> (3) </math>. В них производится вычисление новых центров кластеров, значения решающей функции и пересчет элементов матрицы принадлежности.

== Макроструктура алгоритма ==
Макроструктура алгоритма состоит из следующих шагов:

# Инициализация матрицы <math> M </math> случайными значениями от 0 до 1;
# Вычисление центров кластеров;
# Вычисление значения решающей функции(если оно удовлетворяет условиям останова - завершение вычислений);
# Вычисление новых элементов матрицы принадлежности;
# Переход к шагу 2;

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

Пример реализации алгоритма на языке С++. Сначала вычислим центры кластеров, потом вычислим решающую функцию, с ее помощью определим необходимость продолжать алгоритм, и при необходимости вычислим новые значения матрицы M.
<source lang="C++">

float ** m;
int *c;
int number_clusters, number_items;
m = gen_random_clusters();//заполним матрицу m случайными значениями от 0 до 1

while (true)
{
//вычисление центров кластеров
for (int i=0; i<number_clusters; i++)
{
numerator==denumerator=0;
for (int k=0; k<number_items; k++)
{
numerator+=pow(m[i, k], q)*u[k];//u[k]-вектор
denumerator+=pow(m[i, k], q);
}
c[i]= numerator / denumerator;//центры кластеров
}

j=0;//вычисление решающей функции
for (int i=0; i<number_clusters; i++)
for (int k=0; k<number_items; k++)
j+=pow(m[i, k], q)*pow(dist(c[i], x[k],2);//dist-вычисляет расстояние между заданными векторами

if ((abs(j-last_j)<delta) || (j<eps)) break;//проверка на необходимость завернешения алгоритма
last_j=j;
//обновление матрицы m
for (int i=0; i<number_clusters; i++)
for (int k=0; k<number_items; k++)
{
m[i,k]=0
for(int j=0; j<number_clusters; j++)
m[i,k]+=pow(dist(c[i], x[k])/dist(c[j], x[k]),2/(q-1));
m[i,k]=1/m[i,k];
}

}
</source>

== Последовательная сложность алгоритма ==
Каждая итерация включает в себя
* Вычисление центров кластеров <math>O(C*K)</math>
* Вычисление решающей функции <math>O(C*K)</math>
* Обновлене матрицы <math>M</math> <math>O(C*C*K)</math>
Общая сложность каждой итерации <math>O(C*C*K)</math>.

Сложность всего алгоритма будет зависеть от числа итераций, которое зависит от
* Выбора начального приближения
* Выбора условий останова

Окончательно, сложность алгоритма будет равна произведению количества итераций на их сложность

== Информационный граф ==
'''Первый ярус''' состоит из <math>C</math> параллельных операций, каждая их которых в свою очередь состоит из <math>K</math> параллельных операций, и одной, которая выполняется с использованием результата предыдущих.
Результатом работы этого яруса являются значения центров кластеров , которые будут использоваться на следующем ярусе.

'''Второй ярус''' содержит в себе <math>C*K</math> параллельных операций.
Результатом его работы является значение решающей функции <math>J</math>. Её значение определяет необходимость завершения алгоритма.

'''Третий ярус''' включает <math>C*K</math> параллельных операций, каждая из которых состоит из <math>C</math> параллельных операций, и одной, которая выполняется с использованием результата предыдущих.

[[Файл:Суперпрак.jpg|582 px|thumb|center|Информационный граф алгоритма. Салатовым цветом обозначены вершины графа-операции. Дугами обозначена передача информации, передаваемые данные надписаны сверху.]]

== Ресурс параллелизма алгоритма ==
На каждом шаге алгоритма необходимо вычислять сумму элементов массивов. Сложность ее вычисления на первом шаге (вычисление центров кластеров) при параллельной реализации составляет <math>O(\log_{2} C)</math>. Для каждого элемента из набора входных данных(<math> K </math>), но здесь возможен независимый расчет(координатный параллелизм). На втором шаге(вычисление решающей функции) сложность будет <math>O(\log_{2} {C*K})</math>, потому что здесь необходимо сложение всех элементов. На третьем шаге имеем сложность <math>O(\log_{2} C^2)</math>. Итого суммарная сложность итерации: <math>O(\log_{2} {C*K} + \log_{2} C^3)</math>. Воспользовавшись свойствами логарифма произведения получаем: <math>O(\log_{2} {K} + \log_{2} C^4)</math>.

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

== Входные и выходные данные алгоритма ==
Входные данные:
* <math>u_{k} ~k = 1, ..., K</math> - набор входных векторов размерности <math> N </math>;
* <math>C</math> - количество кластеров;
* <math>q</math> - экспоненциальный весовой коэффициент, характеризующий нечеткость;
* <math>\varepsilon > 0, ~\delta > 0</math> - коэффициенты, описывающие точность алгоритма.
Объем входных данных: <math> K*N </math>

Выходные данные:
* <math> M </math> - матрица принадлежности.
Объем выходных данных: <math> C*K </math>

== Свойства алгоритма ==
*Соотношение последовательной и параллельной сложности алгоритма: <math>C*C*K \over {\log_{2} {K} + \log_{2} C^4}</math>. Соответственно при распараллеливании наибольший прирост в производительности мы получим при разбиении большого набора данных на большее число кластеров;
*Вычислительная мощность: <math>{{C^2*K} \over {C*K}} = C</math>. Получается, что на чем большее количество кластеров мы разбиваем набор данных, тем менее затратным становится перемещение данных;
*Алгоритм не является устойчивым, как и другие подобные алгоритмы этого класса(например k-means). Очень многое зависит как от входных данных, так и от изначальных параметров приближения(заполнения матрицы принадлежности => исходных центров кластеров);
*Не является детерминированным. Так же очень многое зависит как от входных данных, так и от изначальных параметров приближения(заполнения матрицы принадлежности => исходных центров кластеров);
*Алгоритм не сбалансирован - доминирует операция умножения. Параллельные ветви алгоритма сбалансированы;
*Степень исхода вершины информационного графа - 2.

= Программная реализация алгоритма =
== Особенности реализации последовательного алгоритма ==
== Локальность данных и вычислений ==
== Возможные способы и особенности параллельной реализации алгоритма ==
== Масштабируемость алгоритма и его реализации ==
== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Можно найти следующие реализации алгоритма
* Для MATLAB http://www.mathworks.com/help/fuzzy/fcm.html
* В PostgreSQL http://num-meth.srcc.msu.ru/zhurnal/tom_2012/v13r207.html
Так же готовые реализации алгоритма и его описание можно найти на сайтах
* https://habrahabr.ru/post/208496/
* http://pythonhosted.org/scikit-fuzzy/auto_examples/plot_cmeans.html
* http://www.codeproject.com/Articles/91675/Computer-Vision-Applications-with-C-Fuzzy-C-means
* https://github.com/gyaikhom/fcm

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

Файл:Суперпрак.jpg

2016-11-02T12:34:37Z

Protsenko:

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

2016-10-29T18:40:48Z

Protsenko:

{{Assignment}}

{{algorithm
| name = Нечеткий алгоритм C средних
| serial_complexity = <math>O(C*C*K*I)</math>., где <math>I</math> - количество итераций
| input_data = <math>K*N</math>, [количество векторов * размерность]
| output_data = <math>C*K</math>, [элементы матрицы принадлежности]
| pf_height = <math>3I</math>
| pf_width = <math>C*C*K</math>
}}

Авторы : [[Участник:Protsenko|Мария Проценко]] (1.5-1.8, 2.7), [[Участник:ADovganich|Андрей Довганич]] (1.1-1.4, 1.9, 1.10)

= Свойства и структура алгоритмов =
== Общее описание алгоритма ==
Нечеткий алгоритм C-средних (fuzzy C-means) позволяет разбить имеющееся множество векторов (точек) мощностью <math>K</math> на заданное число нечетких множеств. Предназначен для кластеризации больших наборов данных. Основным достоинством алгоритма является нечеткость при определении объекта в кластер. Благодаря этому становится возможным определить объекты, которые находятся на границе, в кластеры. Из основного достоинства следует и главный недостаток - неопределенность с объектами, удаленными от центров всех кластеров. В остальном ему присущи стандартные проблемы подобного класса алгоритмов: вычислительная сложность, необходимость задания количества кластеров<ref>Нейский И.М. Классификация и сравнение методов кластеризации</ref>.

Алгоритм был разработан J.C. Dunn в 1973 г.<ref> Dunn, J. C. (1973-01-01). "A Fuzzy Relative of the ISODATA Process and Its Use in Detecting Compact Well-Separated Clusters". Journal of Cybernetics. 3 (3): 32–57. doi:10.1080/01969727308546046. ISSN 0022-0280.</ref>, усовершенствован J.C. Bezdek в 1981 г.<ref> Bezdek, James C. (1981). Pattern Recognition with Fuzzy Objective Function Algorithms. ISBN 0-306-40671-3.</ref>.

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

В общем виде алгоритм можно записать следующим образом:

# Инициализировать матрицу принадлежности;
# Вычислить центры кластеров;
# Вычислить значение решающей функции. Если значение ниже некоторого порогового или его улучшение по сравнению с предыдущей итерацией меньше определенной величины, то остановить вычисления;
# Иначе вычислить новые значения матрицы принадлежности;
# Перейти к шагу 2

== Математическое описание алгоритма ==
Рассмотрим матрицу <math> M = m_{ik} \in[0,1],\; i = 1, ..., c, \; k = 1, ..., K </math>. <math>m_{i,k}</math> - вероятность принадлежности объекта <math>k</math> к кластеру <math>i</math>; <math>c</math> - количество кластеров, <math>K</math> - количество векторов. При этом элементы матрицы удовлетворяют следующим условиям:

* сумма элементов в каждом столбце равна <math>1</math>;

* сумма всех элементов матрицы равно <math>K</math>;

Назовем <math> M </math> матрицей принадлежности.

Пусть <math>c_{i} (i = 1,2,...c)</math> - центры кластеров. Тогда рассмотрим функцию

<math>
\begin{align}
J(M, c_{1}, c_{2},...c_{c}) = \sum_{i = 1}^{c}{J_{i}} = \sum_{i = 1}^{c}\sum_{k = 1}^{K}{m_{ik}^q}d_{ik}^2 ~(1)
\end{align}
</math>

где <math> d_{ik} = \left\Vert{u_{k}-c_{i}}\right\| </math> - Евклидово расстояние между центром кластера и объектом, <math> 1 \le q \le \infty </math> - экспоненциальный весовой коэффициент, характеризующий нечеткость. Будем минимизировать значение функции <math> J </math>. Для этого вычислим центры кластеров по формуле <math> ~(2) </math>.

<math>c_{i} = {{\sum_{k = 1}^{K}{m_{ik}^q} * u_{k}} \over {\sum_{k = 1}^{K}{m_{ik}^q}}}~(2)</math>

где <math>m_{ik}</math> — коэффициент принадлежности <math>u_{k}</math> вектора к кластеру <math>c_{i}</math>

и новые значения матрицы <math> M </math> по формуле <math> ~(3) </math>

<math>m_{ik} = {1 \over \sum_{j = 1}^{c}{({{d_{ik}} \over {d_{jk}}})}^{2 \over q-1}} ~(3)</math>

<math> ~(2) </math> и <math> ~(3) </math>являются необходимым условиями достижения минимума функцией <math> J </math>. Таким образом эти два условия дают нам итерационный процесс.

Полностью алгоритм можно записать следующим образом:

# Инициализировать матрицу принадлежности <math> M </math> случайными значениями от 0 до 1;
# Вычислить центры кластеров <math>c_{i} (i = 1,2,...c)</math> используя формулу <math>~(2)</math>;
# Вычислить значение решающей функции по формуле <math>~(1)</math>. Если значение <math> J < \varepsilon,~\varepsilon > 0</math> или <math> |J_{i} - J_{i-1}| < \delta,~\delta > 0 </math>, то остановить вычисления;
# Иначе вычислить новые значения матрицы М по формуле <math>~(3)</math>;
# Перейти к шагу 2

== Вычислительное ядро алгоритма ==
Вычислительным ядром алгоритма являются формулы: <math> (1) </math>, <math> (2) </math>, <math> (3) </math>. В них производится вычисление новых центров кластеров, значения решающей функции и пересчет элементов матрицы принадлежности.

== Макроструктура алгоритма ==
Макроструктура алгоритма состоит из следующих шагов:

# Инициализация матрицы <math> M </math> случайными значениями от 0 до 1;
# Вычисление центров кластеров;
# Вычисление значения решающей функции(если оно удовлетворяет условиям останова - завершение вычислений);
# Вычисление новых элементов матрицы принадлежности;
# Переход к шагу 2;

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

Пример реализации алгоритма на языке С++. Сначала вычислим центры кластеров, потом вычислим решающую функцию, с ее помощью определим необходимость продолжать алгоритм, и при необходимости вычислим новые значения матрицы M.
<source lang="C++">

float ** m;
int *c;
int number_clusters, number_items;
m = gen_random_clusters();//заполним матрицу m случайными значениями от 0 до 1

while (true)
{
//вычисление центров кластеров
for (int i=0; i<number_clusters; i++)
{
numerator==denumerator=0;
for (int k=0; k<number_items; k++)
{
numerator+=pow(m[i, k], q)*u[k];//u[k]-вектор
denumerator+=pow(m[i, k], q);
}
c[i]= numerator / denumerator;//центры кластеров
}

j=0;//вычисление решающей функции
for (int i=0; i<number_clusters; i++)
for (int k=0; k<number_items; k++)
j+=pow(m[i, k], q)*pow(dist(c[i], x[k],2);//dist-вычисляет расстояние между заданными векторами

if ((abs(j-last_j)<delta) || (j<eps)) break;//проверка на необходимость завернешения алгоритма
last_j=j;
//обновление матрицы m
for (int i=0; i<number_clusters; i++)
for (int k=0; k<number_items; k++)
{
m[i,k]=0
for(int j=0; j<number_clusters; j++)
m[i,k]+=pow(dist(c[i], x[k])/dist(c[j], x[k]),2/(q-1));
m[i,k]=1/m[i,k];
}

}
</source>

== Последовательная сложность алгоритма ==
Каждая итерация включает в себя
* Вычисление центров кластеров <math>O(C*K)</math>
* Вычисление решающей функции <math>O(C*K)</math>
* Обновлене матрицы <math>M</math> <math>O(C*C*K)</math>
Общая сложность каждой итерации <math>O(C*C*K)</math>.

Сложность всего алгоритма будет зависеть от числа итераций, которое зависит от
* Выбора начального приближения
* Выбора условий останова

Окончательно, сложность алгоритма будет равна произведению количества итераций на их сложность

== Информационный граф ==
'''Первый ярус''' состоит из <math>C</math> параллельных операций, каждая их которых в свою очередь состоит из <math>K</math> параллельных операций, и одной, которая выполняется с использованием результата предыдущих.
Результатом работы этого яруса являются значения центров кластеров , которые будут использоваться на следующем ярусе.

'''Второй ярус''' содержит в себе <math>C*K</math> параллельных операций.
Результатом его работы является значение решающей функции <math>J</math>. Её значение определяет необходимость завершения алгоритма.

'''Третий ярус''' включает <math>C*K</math> параллельных операций, каждая из которых состоит из <math>C</math> параллельных операций, и одной, которая выполняется с использованием результата предыдущих.

[[Файл:Снимок экрана 2016-10-15 в 23.10.05.png|582 px|thumb|center|Информационный граф алгоритма. Салатовым цветом обозначены вершины графа-операции. Дугами обозначена передача информации, передаваемые данные надписаны сверху.]]

== Ресурс параллелизма алгоритма ==
На каждом шаге алгоритма необходимо вычислять сумму элементов массивов. Сложность ее вычисления на первом шаге (вычисление центров кластеров) при параллельной реализации составляет <math>O(\log_{2} C)</math>. Для каждого элемента из набора входных данных(<math> K </math>), но здесь возможен независимый расчет(координатный параллелизм). На втором шаге(вычисление решающей функции) сложность будет <math>O(\log_{2} {C*K})</math>, потому что здесь необходимо сложение всех элементов. На третьем шаге имеем сложность <math>O(\log_{2} C^2)</math>. Итого суммарная сложность итерации: <math>O(\log_{2} {C*K} + \log_{2} C^3)</math>. Воспользовавшись свойствами логарифма произведения получаем: <math>O(\log_{2} {K} + \log_{2} C^4)</math>.

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

== Входные и выходные данные алгоритма ==
Входные данные:
* <math>u_{k} ~k = 1, ..., K</math> - набор входных векторов размерности <math> N </math>;
* <math>C</math> - количество кластеров;
* <math>q</math> - экспоненциальный весовой коэффициент, характеризующий нечеткость;
* <math>\varepsilon > 0, ~\delta > 0</math> - коэффициенты, описывающие точность алгоритма.
Объем входных данных: <math> K*N </math>

Выходные данные:
* <math> M </math> - матрица принадлежности.
Объем выходных данных: <math> C*K </math>

== Свойства алгоритма ==
*Соотношение последовательной и параллельной сложности алгоритма: <math>C*C*K \over {\log_{2} {K} + \log_{2} C^4}</math>. Соответственно при распараллеливании наибольший прирост в производительности мы получим при разбиении большого набора данных на большее число кластеров;
*Вычислительная мощность: <math>{{C^2*K} \over {C*K}} = C</math>. Получается, что на чем большее количество кластеров мы разбиваем набор данных, тем менее затратным становится перемещение данных;
*Алгоритм не является устойчивым, как и другие подобные алгоритмы этого класса(например k-means). Очень многое зависит как от входных данных, так и от изначальных параметров приближения(заполнения матрицы принадлежности => исходных центров кластеров);
*Не является детерминированным. Так же очень многое зависит как от входных данных, так и от изначальных параметров приближения(заполнения матрицы принадлежности => исходных центров кластеров);
*Алгоритм не сбалансирован - доминирует операция умножения. Параллельные ветви алгоритма сбалансированы;
*Степень исхода вершины информационного графа - 2.

= Программная реализация алгоритма =
== Особенности реализации последовательного алгоритма ==
== Локальность данных и вычислений ==
== Возможные способы и особенности параллельной реализации алгоритма ==
== Масштабируемость алгоритма и его реализации ==
== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Можно найти следующие реализации алгоритма
* Для MATLAB http://www.mathworks.com/help/fuzzy/fcm.html
* В PostgreSQL http://num-meth.srcc.msu.ru/zhurnal/tom_2012/v13r207.html
Так же готовые реализации алгоритма и его описание можно найти на сайтах
* https://habrahabr.ru/post/208496/
* http://pythonhosted.org/scikit-fuzzy/auto_examples/plot_cmeans.html
* http://www.codeproject.com/Articles/91675/Computer-Vision-Applications-with-C-Fuzzy-C-means
* https://github.com/gyaikhom/fcm

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

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

2016-10-29T18:39:07Z

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

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

=== Замечания по тексту ===
* В разделе 1.5 кроме текста программы нужны словесные пояснения. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 16:38, 27 октября 2016 (MSK)
* Граф, представленный в разделе 1.7, не является информационным графом (ациклический граф, вершины - операции, дуги - информационные зависимости). [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 16:38, 27 октября 2016 (MSK)
* В разделе 1.9 требуется привести оценки объёма входных и выходных данных. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 16:38, 27 октября 2016 (MSK)

Исправлено

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

2016-10-29T18:38:38Z

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

{{algorithm
| name = Нечеткий алгоритм C средних
| serial_complexity = <math>O(C*C*K*I)</math>., где <math>I</math> - количество итераций
| input_data = <math>K*N</math>, [количество векторов * размерность]
| output_data = <math>C*K</math>, [элементы матрицы принадлежности]
| pf_height = <math>3I</math>
| pf_width = <math>C*C*K</math>
}}

Авторы : [[Участник:Protsenko|Мария Проценко]] (1.5-1.8, 2.7), [[Участник:ADovganich|Андрей Довганич]] (1.1-1.4, 1.9, 1.10)

= Свойства и структура алгоритмов =
== Общее описание алгоритма ==
Нечеткий алгоритм C-средних (fuzzy C-means) позволяет разбить имеющееся множество векторов (точек) мощностью <math>K</math> на заданное число нечетких множеств. Предназначен для кластеризации больших наборов данных. Основным достоинством алгоритма является нечеткость при определении объекта в кластер. Благодаря этому становится возможным определить объекты, которые находятся на границе, в кластеры. Из основного достоинства следует и главный недостаток - неопределенность с объектами, удаленными от центров всех кластеров. В остальном ему присущи стандартные проблемы подобного класса алгоритмов: вычислительная сложность, необходимость задания количества кластеров<ref>Нейский И.М. Классификация и сравнение методов кластеризации</ref>.

Алгоритм был разработан J.C. Dunn в 1973 г.<ref> Dunn, J. C. (1973-01-01). "A Fuzzy Relative of the ISODATA Process and Its Use in Detecting Compact Well-Separated Clusters". Journal of Cybernetics. 3 (3): 32–57. doi:10.1080/01969727308546046. ISSN 0022-0280.</ref>, усовершенствован J.C. Bezdek в 1981 г.<ref> Bezdek, James C. (1981). Pattern Recognition with Fuzzy Objective Function Algorithms. ISBN 0-306-40671-3.</ref>.

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

В общем виде алгоритм можно записать следующим образом:

# Инициализировать матрицу принадлежности;
# Вычислить центры кластеров;
# Вычислить значение решающей функции. Если значение ниже некоторого порогового или его улучшение по сравнению с предыдущей итерацией меньше определенной величины, то остановить вычисления;
# Иначе вычислить новые значения матрицы принадлежности;
# Перейти к шагу 2

== Математическое описание алгоритма ==
Рассмотрим матрицу <math> M = m_{ik} \in[0,1],\; i = 1, ..., c, \; k = 1, ..., K </math>. <math>m_{i,k}</math> - вероятность принадлежности объекта <math>k</math> к кластеру <math>i</math>; <math>c</math> - количество кластеров, <math>K</math> - количество векторов. При этом элементы матрицы удовлетворяют следующим условиям:

* сумма элементов в каждом столбце равна <math>1</math>;

* сумма всех элементов матрицы равно <math>K</math>;

Назовем <math> M </math> матрицей принадлежности.

Пусть <math>c_{i} (i = 1,2,...c)</math> - центры кластеров. Тогда рассмотрим функцию

<math>
\begin{align}
J(M, c_{1}, c_{2},...c_{c}) = \sum_{i = 1}^{c}{J_{i}} = \sum_{i = 1}^{c}\sum_{k = 1}^{K}{m_{ik}^q}d_{ik}^2 ~(1)
\end{align}
</math>

где <math> d_{ik} = \left\Vert{u_{k}-c_{i}}\right\| </math> - Евклидово расстояние между центром кластера и объектом, <math> 1 \le q \le \infty </math> - экспоненциальный весовой коэффициент, характеризующий нечеткость. Будем минимизировать значение функции <math> J </math>. Для этого вычислим центры кластеров по формуле <math> ~(2) </math>.

<math>c_{i} = {{\sum_{k = 1}^{K}{m_{ik}^q} * u_{k}} \over {\sum_{k = 1}^{K}{m_{ik}^q}}}~(2)</math>

где <math>m_{ik}</math> — коэффициент принадлежности <math>u_{k}</math> вектора к кластеру <math>c_{i}</math>

и новые значения матрицы <math> M </math> по формуле <math> ~(3) </math>

<math>m_{ik} = {1 \over \sum_{j = 1}^{c}{({{d_{ik}} \over {d_{jk}}})}^{2 \over q-1}} ~(3)</math>

<math> ~(2) </math> и <math> ~(3) </math>являются необходимым условиями достижения минимума функцией <math> J </math>. Таким образом эти два условия дают нам итерационный процесс.

Полностью алгоритм можно записать следующим образом:

# Инициализировать матрицу принадлежности <math> M </math> случайными значениями от 0 до 1;
# Вычислить центры кластеров <math>c_{i} (i = 1,2,...c)</math> используя формулу <math>~(2)</math>;
# Вычислить значение решающей функции по формуле <math>~(1)</math>. Если значение <math> J < \varepsilon,~\varepsilon > 0</math> или <math> |J_{i} - J_{i-1}| < \delta,~\delta > 0 </math>, то остановить вычисления;
# Иначе вычислить новые значения матрицы М по формуле <math>~(3)</math>;
# Перейти к шагу 2

== Вычислительное ядро алгоритма ==
Вычислительным ядром алгоритма являются формулы: <math> (1) </math>, <math> (2) </math>, <math> (3) </math>. В них производится вычисление новых центров кластеров, значения решающей функции и пересчет элементов матрицы принадлежности.

== Макроструктура алгоритма ==
Макроструктура алгоритма состоит из следующих шагов:

# Инициализация матрицы <math> M </math> случайными значениями от 0 до 1;
# Вычисление центров кластеров;
# Вычисление значения решающей функции(если оно удовлетворяет условиям останова - завершение вычислений);
# Вычисление новых элементов матрицы принадлежности;
# Переход к шагу 2;

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

Пример реализации алгоритма на языке С++. Сначала вычислим центры кластеров, потом вычислим решающую функцию, с ее помощью определим необходимость продолжать алгоритм, и при необходимости вычислим новые значения матрицы M.
<source lang="C++">

float ** m;
int *c;
int number_clusters, number_items;
m = gen_random_clusters();//заполним матрицу m случайными значениями от 0 до 1

while (true)
{
//вычисление центров кластеров
for (int i=0; i<number_clusters; i++)
{
numerator==denumerator=0;
for (int k=0; k<number_items; k++)
{
numerator+=pow(m[i, k], q)*u[k];//u[k]-вектор
denumerator+=pow(m[i, k], q);
}
c[i]= numerator / denumerator;//центры кластеров
}

j=0;//вычисление решающей функции
for (int i=0; i<number_clusters; i++)
for (int k=0; k<number_items; k++)
j+=pow(m[i, k], q)*pow(dist(c[i], x[k],2);//dist-вычисляет расстояние между заданными векторами

if ((abs(j-last_j)<delta) || (j<eps)) break;//проверка на необходимость завернешения алгоритма
last_j=j;
//обновление матрицы m
for (int i=0; i<number_clusters; i++)
for (int k=0; k<number_items; k++)
{
m[i,k]=0
for(int j=0; j<number_clusters; j++)
m[i,k]+=pow(dist(c[i], x[k])/dist(c[j], x[k]),2/(q-1));
m[i,k]=1/m[i,k];
}

}
</source>

== Последовательная сложность алгоритма ==
Каждая итерация включает в себя
* Вычисление центров кластеров <math>O(C*K)</math>
* Вычисление решающей функции <math>O(C*K)</math>
* Обновлене матрицы <math>M</math> <math>O(C*C*K)</math>
Общая сложность каждой итерации <math>O(C*C*K)</math>.

Сложность всего алгоритма будет зависеть от числа итераций, которое зависит от
* Выбора начального приближения
* Выбора условий останова

Окончательно, сложность алгоритма будет равна произведению количества итераций на их сложность

== Информационный граф ==
'''Первый ярус''' состоит из <math>C</math> параллельных операций, каждая их которых в свою очередь состоит из <math>K</math> параллельных операций, и одной, которая выполняется с использованием результата предыдущих.
Результатом работы этого яруса являются значения центров кластеров , которые будут использоваться на следующем ярусе.

'''Второй ярус''' содержит в себе <math>C*K</math> параллельных операций.
Результатом его работы является значение решающей функции <math>J</math>. Её значение определяет необходимость завершения алгоритма.

'''Третий ярус''' включает <math>C*K</math> параллельных операций, каждая из которых состоит из <math>C</math> параллельных операций, и одной, которая выполняется с использованием результата предыдущих.

[[Файл:Снимок экрана 2016-10-15 в 23.10.05.png|582 px|thumb|center|Информационный граф алгоритма. Салатовым цветом обозначены вершины графа-операции. Дугами обозначена передача информации, передаваемые данные надписаны сверху.]]

== Ресурс параллелизма алгоритма ==
На каждом шаге алгоритма необходимо вычислять сумму элементов массивов. Сложность ее вычисления на первом шаге (вычисление центров кластеров) при параллельной реализации составляет <math>O(\log_{2} C)</math>. Для каждого элемента из набора входных данных(<math> K </math>), но здесь возможен независимый расчет(координатный параллелизм). На втором шаге(вычисление решающей функции) сложность будет <math>O(\log_{2} {C*K})</math>, потому что здесь необходимо сложение всех элементов. На третьем шаге имеем сложность <math>O(\log_{2} C^2)</math>. Итого суммарная сложность итерации: <math>O(\log_{2} {C*K} + \log_{2} C^3)</math>. Воспользовавшись свойствами логарифма произведения получаем: <math>O(\log_{2} {K} + \log_{2} C^4)</math>.

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

== Входные и выходные данные алгоритма ==
Входные данные:
* <math>u_{k} ~k = 1, ..., K</math> - набор входных векторов размерности <math> N </math>;
* <math>C</math> - количество кластеров;
* <math>q</math> - экспоненциальный весовой коэффициент, характеризующий нечеткость;
* <math>\varepsilon > 0, ~\delta > 0</math> - коэффициенты, описывающие точность алгоритма.
Объем входных данных: <math> K*N </math>

Выходные данные:
* <math> M </math> - матрица принадлежности.
Объем выходных данных: <math> C*K </math>

== Свойства алгоритма ==
*Соотношение последовательной и параллельной сложности алгоритма: <math>C*C*K \over {\log_{2} {K} + \log_{2} C^4}</math>. Соответственно при распараллеливании наибольший прирост в производительности мы получим при разбиении большого набора данных на большее число кластеров;
*Вычислительная мощность: <math>{{C^2*K} \over {C*K}} = C</math>. Получается, что на чем большее количество кластеров мы разбиваем набор данных, тем менее затратным становится перемещение данных;
*Алгоритм не является устойчивым, как и другие подобные алгоритмы этого класса(например k-means). Очень многое зависит как от входных данных, так и от изначальных параметров приближения(заполнения матрицы принадлежности => исходных центров кластеров);
*Не является детерминированным. Так же очень многое зависит как от входных данных, так и от изначальных параметров приближения(заполнения матрицы принадлежности => исходных центров кластеров);
*Алгоритм не сбалансирован - доминирует операция умножения. Параллельные ветви алгоритма сбалансированы;
*Степень исхода вершины информационного графа - 2.

= Программная реализация алгоритма =
== Особенности реализации последовательного алгоритма ==
== Локальность данных и вычислений ==
== Возможные способы и особенности параллельной реализации алгоритма ==
== Масштабируемость алгоритма и его реализации ==
== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Можно найти следующие реализации алгоритма
* Для MATLAB http://www.mathworks.com/help/fuzzy/fcm.html
* В PostgreSQL http://num-meth.srcc.msu.ru/zhurnal/tom_2012/v13r207.html
Так же готовые реализации алгоритма и его описание можно найти на сайтах
* https://habrahabr.ru/post/208496/
* http://pythonhosted.org/scikit-fuzzy/auto_examples/plot_cmeans.html
* http://www.codeproject.com/Articles/91675/Computer-Vision-Applications-with-C-Fuzzy-C-means
* https://github.com/gyaikhom/fcm

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

Файл:Снимок экрана 2016-10-15 в 23.10.05.png

2016-10-29T18:36:42Z

Protsenko: Protsenko загрузил новую версию Файл:Снимок экрана 2016-10-15 в 23.10.05.png

Информационный граф алгоритма c-means

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

2016-10-28T21:48:34Z

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

{{algorithm
| name = Нечеткий алгоритм C средних
| serial_complexity = <math>O(C*C*K*I)</math>., где <math>I</math> - количество итераций
| input_data = <math>K*N</math>, [количество векторов * размерность]
| output_data = <math>C*K</math>, [элементы матрицы принадлежности]
| pf_height = <math>3I</math>
| pf_width = <math>C*C*K</math>
}}

Авторы : [[Участник:Protsenko|Мария Проценко]] (1.5-1.8, 2.7), [[Участник:ADovganich|Андрей Довганич]] (1.1-1.4, 1.9, 1.10)

= Свойства и структура алгоритмов =
== Общее описание алгоритма ==
Нечеткий алгоритм C-средних (fuzzy C-means) позволяет разбить имеющееся множество векторов (точек) мощностью <math>K</math> на заданное число нечетких множеств. Предназначен для кластеризации больших наборов данных. Основным достоинством алгоритма является нечеткость при определении объекта в кластер. Благодаря этому становится возможным определить объекты, которые находятся на границе, в кластеры. Из основного достоинства следует и главный недостаток - неопределенность с объектами, удаленными от центров всех кластеров. В остальном ему присущи стандартные проблемы подобного класса алгоритмов: вычислительная сложность, необходимость задания количества кластеров<ref>Нейский И.М. Классификация и сравнение методов кластеризации</ref>.

Алгоритм был разработан J.C. Dunn в 1973 г.<ref> Dunn, J. C. (1973-01-01). "A Fuzzy Relative of the ISODATA Process and Its Use in Detecting Compact Well-Separated Clusters". Journal of Cybernetics. 3 (3): 32–57. doi:10.1080/01969727308546046. ISSN 0022-0280.</ref>, усовершенствован J.C. Bezdek в 1981 г.<ref> Bezdek, James C. (1981). Pattern Recognition with Fuzzy Objective Function Algorithms. ISBN 0-306-40671-3.</ref>.

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

В общем виде алгоритм можно записать следующим образом:

# Инициализировать матрицу принадлежности;
# Вычислить центры кластеров;
# Вычислить значение решающей функции. Если значение ниже некоторого порогового или его улучшение по сравнению с предыдущей итерацией меньше определенной величины, то остановить вычисления;
# Иначе вычислить новые значения матрицы принадлежности;
# Перейти к шагу 2

== Математическое описание алгоритма ==
Рассмотрим матрицу <math> M = m_{ik} \in[0,1],\; i = 1, ..., c, \; k = 1, ..., K </math>. <math>m_{i,k}</math> - вероятность принадлежности объекта <math>k</math> к кластеру <math>i</math>; <math>c</math> - количество кластеров, <math>K</math> - количество векторов. При этом элементы матрицы удовлетворяют следующим условиям:

* сумма элементов в каждом столбце равна <math>1</math>;

* сумма всех элементов матрицы равно <math>K</math>;

Назовем <math> M </math> матрицей принадлежности.

Пусть <math>c_{i} (i = 1,2,...c)</math> - центры кластеров. Тогда рассмотрим функцию

<math>
\begin{align}
J(M, c_{1}, c_{2},...c_{c}) = \sum_{i = 1}^{c}{J_{i}} = \sum_{i = 1}^{c}\sum_{k = 1}^{K}{m_{ik}^q}d_{ik}^2 ~(1)
\end{align}
</math>

где <math> d_{ik} = \left\Vert{u_{k}-c_{i}}\right\| </math> - Евклидово расстояние между центром кластера и объектом, <math> 1 \le q \le \infty </math> - экспоненциальный весовой коэффициент, характеризующий нечеткость. Будем минимизировать значение функции <math> J </math>. Для этого вычислим центры кластеров по формуле <math> ~(2) </math>.

<math>c_{i} = {{\sum_{k = 1}^{K}{m_{ik}^q} * u_{k}} \over {\sum_{k = 1}^{K}{m_{ik}^q}}}~(2)</math>

где <math>m_{ik}</math> — коэффициент принадлежности <math>u_{k}</math> вектора к кластеру <math>c_{i}</math>

и новые значения матрицы <math> M </math> по формуле <math> ~(3) </math>

<math>m_{ik} = {1 \over \sum_{j = 1}^{c}{({{d_{ik}} \over {d_{jk}}})}^{2 \over q-1}} ~(3)</math>

<math> ~(2) </math> и <math> ~(3) </math>являются необходимым условиями достижения минимума функцией <math> J </math>. Таким образом эти два условия дают нам итерационный процесс.

Полностью алгоритм можно записать следующим образом:

# Инициализировать матрицу принадлежности <math> M </math> случайными значениями от 0 до 1;
# Вычислить центры кластеров <math>c_{i} (i = 1,2,...c)</math> используя формулу <math>~(2)</math>;
# Вычислить значение решающей функции по формуле <math>~(1)</math>. Если значение <math> J < \varepsilon,~\varepsilon > 0</math> или <math> |J_{i} - J_{i-1}| < \delta,~\delta > 0 </math>, то остановить вычисления;
# Иначе вычислить новые значения матрицы М по формуле <math>~(3)</math>;
# Перейти к шагу 2

== Вычислительное ядро алгоритма ==
Вычислительным ядром алгоритма являются формулы: <math> (1) </math>, <math> (2) </math>, <math> (3) </math>. В них производится вычисление новых центров кластеров, значения решающей функции и пересчет элементов матрицы принадлежности.

== Макроструктура алгоритма ==
Макроструктура алгоритма состоит из следующих шагов:

# Инициализация матрицы <math> M </math> случайными значениями от 0 до 1;
# Вычисление центров кластеров;
# Вычисление значения решающей функции(если оно удовлетворяет условиям останова - завершение вычислений);
# Вычисление новых элементов матрицы принадлежности;
# Переход к шагу 2;

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

Пример реализации алгоритма на языке С++. Сначала вычислим центры кластеров, потом вычислим решающую функцию, с ее помощью определим необходимость продолжать алгоритм, и при необходимости вычислим новые значения матрицы M.
<source lang="C++">

float ** m;
int *c;
int number_clusters, number_items;
m = gen_random_clusters();//заполним матрицу m случайными значениями от 0 до 1

while (true)
{
//вычисление центров кластеров
for (int i=0; i<number_clusters; i++)
{
numerator==denumerator=0;
for (int k=0; k<number_items; k++)
{
numerator+=pow(m[i, k], q)*u[k];//u[k]-вектор
denumerator+=pow(m[i, k], q);
}
c[i]= numerator / denumerator;//центры кластеров
}

j=0;//вычисление решающей функции
for (int i=0; i<number_clusters; i++)
for (int k=0; k<number_items; k++)
j+=pow(m[i, k], q)*pow(dist(c[i], x[k],2);//dist-вычисляет расстояние между заданными векторами

if ((abs(j-last_j)<delta) || (j<eps)) break;//проверка на необходимость завернешения алгоритма
last_j=j;
//обновление матрицы m
for (int i=0; i<number_clusters; i++)
for (int k=0; k<number_items; k++)
{
m[i,k]=0
for(int j=0; j<number_clusters; j++)
m[i,k]+=pow(dist(c[i], x[k])/dist(c[j], x[k]),2/(q-1));
m[i,k]=1/m[i,k];
}

}
</source>

== Последовательная сложность алгоритма ==
Каждая итерация включает в себя
* Вычисление центров кластеров <math>O(C*K)</math>
* Вычисление решающей функции <math>O(C*K)</math>
* Обновлене матрицы <math>M</math> <math>O(C*C*K)</math>
Общая сложность каждой итерации <math>O(C*C*K)</math>.

Сложность всего алгоритма будет зависеть от числа итераций, которое зависит от
* Выбора начального приближения
* Выбора условий останова

Окончательно, сложность алгоритма будет равна произведению количества итераций на их сложность

== Информационный граф ==
'''Первый ярус''' состоит из <math>C</math> параллельных операций, каждая их которых в свою очередь состоит из <math>K</math> параллельных операций, и одной, которая выполняется с использованием результата предыдущих.
Результатом работы этого яруса являются значения центров кластеров , которые будут использоваться на следующем ярусе.

'''Второй ярус''' содержит в себе <math>C*K</math> параллельных операций.
Результатом его работы является значение решающей функции <math>J</math>. Её значение определяет необходимость завершения алгоритма.

'''Третий ярус''' включает <math>C*K</math> параллельных операций, каждая из которых состоит из <math>C</math> параллельных операций, и одной, которая выполняется с использованием результата предыдущих.

[[Файл:Снимок экрана 2016-10-15 в 23.10.05.png|582 px|thumb|center|Информационный граф]]

== Ресурс параллелизма алгоритма ==
На каждом шаге алгоритма необходимо вычислять сумму элементов массивов. Сложность ее вычисления на первом шаге (вычисление центров кластеров) при параллельной реализации составляет <math>O(\log_{2} C)</math>. Для каждого элемента из набора входных данных(<math> K </math>), но здесь возможен независимый расчет(координатный параллелизм). На втором шаге(вычисление решающей функции) сложность будет <math>O(\log_{2} {C*K})</math>, потому что здесь необходимо сложение всех элементов. На третьем шаге имеем сложность <math>O(\log_{2} C^2)</math>. Итого суммарная сложность итерации: <math>O(\log_{2} {C*K} + \log_{2} C^3)</math>. Воспользовавшись свойствами логарифма произведения получаем: <math>O(\log_{2} {K} + \log_{2} C^4)</math>.

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

== Входные и выходные данные алгоритма ==
Входные данные:
* <math>u_{k} ~k = 1, ..., K</math> - набор входных векторов размерности <math> N </math>;
* <math>C</math> - количество кластеров;
* <math>q</math> - экспоненциальный весовой коэффициент, характеризующий нечеткость;
* <math>\varepsilon > 0, ~\delta > 0</math> - коэффициенты, описывающие точность алгоритма.
Объем входных данных: <math> K*N </math>

Выходные данные:
* <math> M </math> - матрица принадлежности.
Объем выходных данных: <math> C*K </math>

== Свойства алгоритма ==
*Соотношение последовательной и параллельной сложности алгоритма: <math>C*C*K \over {\log_{2} {K} + \log_{2} C^4}</math>. Соответственно при распараллеливании наибольший прирост в производительности мы получим при разбиении большого набора данных на большее число кластеров;
*Вычислительная мощность: <math>{{C^2*K} \over {C*K}} = C</math>. Получается, что на чем большее количество кластеров мы разбиваем набор данных, тем менее затратным становится перемещение данных;
*Алгоритм не является устойчивым, как и другие подобные алгоритмы этого класса(например k-means). Очень многое зависит как от входных данных, так и от изначальных параметров приближения(заполнения матрицы принадлежности => исходных центров кластеров);
*Не является детерминированным. Так же очень многое зависит как от входных данных, так и от изначальных параметров приближения(заполнения матрицы принадлежности => исходных центров кластеров);
*Алгоритм не сбалансирован - доминирует операция умножения. Параллельные ветви алгоритма сбалансированы;
*Степень исхода вершины информационного графа - 2.

= Программная реализация алгоритма =
== Особенности реализации последовательного алгоритма ==
== Локальность данных и вычислений ==
== Возможные способы и особенности параллельной реализации алгоритма ==
== Масштабируемость алгоритма и его реализации ==
== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Можно найти следующие реализации алгоритма
* Для MATLAB http://www.mathworks.com/help/fuzzy/fcm.html
* В PostgreSQL http://num-meth.srcc.msu.ru/zhurnal/tom_2012/v13r207.html
Так же готовые реализации алгоритма и его описание можно найти на сайтах
* https://habrahabr.ru/post/208496/
* http://pythonhosted.org/scikit-fuzzy/auto_examples/plot_cmeans.html
* http://www.codeproject.com/Articles/91675/Computer-Vision-Applications-with-C-Fuzzy-C-means
* https://github.com/gyaikhom/fcm

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

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

2016-10-15T21:08:43Z

Protsenko:

{{Assignment}}

{{algorithm
| name = Нечеткий алгоритм C средних
| serial_complexity = <math>O(C*C*K*I)</math>., где <math>I</math> - количество итераций
| input_data = <math>u_{k} k = 1, ..., K</math>, [вектора]
| output_data = <math>M</math>, [матрица принадлежности]
| pf_height = <math>3I</math>
| pf_width = <math>C*C*K</math>
}}

Авторы : [[Участник:Protsenko|Мария Проценко]] (1.5-1.8, 2.7), [[Участник:ADovganich|Андрей Довганич]] (1.1-1.4, 1.9, 1.10)

= Свойства и структура алгоритмов =
== Общее описание алгоритма ==
Нечеткий алгоритм C-средних (fuzzy C-means) позволяет разбить имеющееся множество векторов (точек) мощностью K на заданное число нечетких множеств. Предназначен для кластеризации больших наборов данных. Основным достоинством алгоритма является нечеткость при определении объекта в кластер. Благодаря этому становится возможным определить объекты, которые находятся на границе, в кластеры. Из основного достоинства следует и главный недостаток - неопределенность с объектами, удаленными от центров всех кластеров. В остальном ему присущи стандартные проблемы подобного класса алгоритмов: вычислительная сложность, необходимость задания количества кластеров<ref>Нейский И.М. Классификация и сравнение методов кластеризации</ref>.

Алгоритм был разработан J.C. Dunn в 1973 г.<ref> Dunn, J. C. (1973-01-01). "A Fuzzy Relative of the ISODATA Process and Its Use in Detecting Compact Well-Separated Clusters". Journal of Cybernetics. 3 (3): 32–57. doi:10.1080/01969727308546046. ISSN 0022-0280.</ref>, усовершенствован J.C. Bezdek в 1981 г.<ref> Bezdek, James C. (1981). Pattern Recognition with Fuzzy Objective Function Algorithms. ISBN 0-306-40671-3.</ref>.

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

В общем виде алгоритм можно записать следующим образом:

# Инициализировать матрицу принадлежности;
# Вычислить центры кластеров;
# Вычислить значение решающей функции. Если значение ниже некоторого порогового или его улучшение по сравнению с предыдущей итерацией меньше определенной величины, то остановить вычисления;
# Иначе вычислить новые значения матрицы принадлежности;
# Перейти к шагу 2

== Математическое описание алгоритма ==
Рассмотрим матрицу <math> M = m_{ik} \in[0,1],\; i = 1, ..., c, \; k = 1, ..., K </math>. <math>m_{i,k}</math> - вероятность принадлежности объекта <math>k</math> к кластеру <math>i</math>; <math>c</math> - количество кластеров, <math>K</math> - количество векторов. При этом элементы матрицы удовлетворяют следующим условиям:

* сумма элементов в каждом столбце равна <math>1</math>;

* сумма всех элементов матрицы равно <math>K</math>;

Назовем <math> M </math> матрицей принадлежности.

Пусть <math>c_{i} (i = 1,2,...c)</math> - центры кластеров. Тогда рассмотрим функцию

<math>
\begin{align}
J(M, c_{1}, c_{2},...c_{c}) = \sum_{i = 1}^{c}{J_{i}} = \sum_{i = 1}^{c}\sum_{k = 1}^{K}{m_{ik}^q}d_{ik}^2 ~(1)
\end{align}
</math>

где <math> d_{ik} = \left\Vert{u_{k}-c_{i}}\right\| </math> - Евклидово расстояние между центром кластера и объектом, <math> 1 \le q \le \infty </math> - экспоненциальный весовой коэффициент, характеризующий нечеткость. Будем минимизировать значение функции <math> J </math>. Для этого вычислим центры кластеров по формуле <math> ~(2) </math>.

<math>c_{i} = {{\sum_{k = 1}^{K}{m_{ik}^q} * u_{k}} \over {\sum_{k = 1}^{K}{m_{ik}^q}}}~(2)</math>

где <math>m_{ik}</math> — коэффициент принадлежности <math>u_{k}</math> вектора к кластеру <math>c_{i}</math>

и новые значения матрицы <math> M </math> по формуле <math> ~(3) </math>

<math>m_{ik} = {1 \over \sum_{j = 1}^{c}{({{d_{ik}} \over {d_{jk}}})}^{2 \over q-1}} ~(3)</math>

<math> ~(2) </math> и <math> ~(3) </math>являются необходимым условиями достижения минимума функцией <math> J </math>. Таким образом эти два условия дают нам итерационный процесс.

Полностью алгоритм можно записать следующим образом:

# Инициализировать матрицу принадлежности <math> M </math> случайными значениями от 0 до 1;
# Вычислить центры кластеров <math>c_{i} (i = 1,2,...c)</math> используя формулу <math>~(2)</math>;
# Вычислить значение решающей функции по формуле <math>~(1)</math>. Если значение <math> J < \varepsilon,~\varepsilon > 0</math> или <math> |J_{i} - J_{i-1}| < \delta,~\delta > 0 </math>, то остановить вычисления;
# Иначе вычислить новые значения матрицы М по формуле <math>~(3)</math>;
# Перейти к шагу 2

== Вычислительное ядро алгоритма ==
Вычислительным ядром алгоритма являются формулы: <math> (1) </math>, <math> (2) </math>, <math> (3) </math>. В них производится вычисление новых центров кластеров, значения решающей функции и пересчет элементов матрицы принадлежности.

== Макроструктура алгоритма ==
Макроструктура алгоритма состоит из следующих шагов:

# Инициализация матрицы <math> M </math> случайными значениями от 0 до 1;
# Вычисление центров кластеров;
# Вычисление значения решающей функции(если оно удовлетворяет условиям останова - завершение вычислений);
# Вычисление новых элементов матрицы принадлежности;
# Переход к шагу 2;

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

Пример реализации алгоритма на языке С++
<source lang="C++">

float ** m;
int *c;
int number_clusters, number_items;
m = gen_random_clusters();//заполним матрицу m случайными значениями от 0 до 1

while (true)
{
//вычисление центров кластеров
for (int i=0; i<number_clusters; i++)
{
numerator==denumerator=0;
for (int k=0; k<number_items; k++)
{
numerator+=pow(m[i, k], q)*u[k];//u[k]-вектор
denumerator+=pow(m[i, k], q);
}
c[i]= numerator / denumerator;//центры кластеров
}

j=0;//вычисление решающей функции
for (int i=0; i<number_clusters; i++)
for (int k=0; k<number_items; k++)
j+=pow(m[i, k], q)*pow(dist(c[i], x[k],2);//dist-вычисляет расстояние между заданными векторами

if ((abs(j-last_j)<delta) || (j<eps)) break;//проверка на необходимость завернешения алгоритма
last_j=j;
//обновление матрицы m
for (int i=0; i<number_clusters; i++)
for (int k=0; k<number_items; k++)
{
m[i,k]=0
for(int j=0; j<number_clusters; j++)
m[i,k]+=pow(dist(c[i], x[k])/dist(c[j], x[k]),2/(q-1));
m[i,k]=1/m[i,k];
}

}
</source>

== Последовательная сложность алгоритма ==
Каждая итерация включает в себя
* Вычисление центров кластеров <math>O(C*K)</math>
* Вычисление решающей функции <math>O(C*K)</math>
* Обновлене матрицы <math>M</math> <math>O(C*C*K)</math>
Общая сложность каждой итерации <math>O(C*C*K)</math>.

Сложность всего алгоритма будет зависеть от числа итераций, которое зависит от
* Выбора начального приближения
* Выбора условий останова

Окончательно, сложность алгоритма будет равна произведению количества итераций на их сложность

== Информационный граф ==
'''Первый ярус''' состоит из <math>C</math> параллельных операций, каждая их которых в свою очередь состоит из <math>K</math> параллельных операций, и одной, которая выполняется с использованием результата предыдущих.
Результатом работы этого яруса являются значения центров кластеров , которые будут использоваться на следующем ярусе.

'''Второй ярус''' содержит в себе <math>C*K</math> параллельных операций.
Результатом его работы является значение решающей функции <math>J</math>. Её значение определяет необходимость завершения алгоритма.

'''Третий ярус''' включает <math>C*K</math> параллельных операций, каждая из которых состоит из <math>C</math> параллельных операций, и одной, которая выполняется с использованием результата предыдущих.

[[Файл:Снимок экрана 2016-10-15 в 23.10.05.png|582 px|thumb|center|Информационный граф]]

== Ресурс параллелизма алгоритма ==
На каждом шаге алгоритма необходимо вычислять сумму элементов массивов. Сложность ее вычисления на первом шаге (вычисление центров кластеров) при параллельной реализации составляет <math>O(\log_{2} C)</math>. Для каждого элемента из набора входных данных(<math> K </math>), но здесь возможен независимый расчет(координатный параллелизм). На втором шаге(вычисление решающей функции) сложность будет <math>O(\log_{2} {C*K})</math>, потому что здесь необходимо сложение всех элементов. На третьем шаге имеем сложность <math>O(\log_{2} C^2)</math>. Итого суммарная сложность итерации: <math>O(\log_{2} {C*K} + \log_{2} C^3)</math>. Воспользовавшись свойствами логарифма произведения получаем: <math>O(\log_{2} {K} + \log_{2} C^4)</math>.

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

== Входные и выходные данные алгоритма ==
Входные данные:
* <math>u_{k} k = 1, ..., K</math> - набор входных векторов;
* <math>C</math> - количество кластеров;
* <math>q</math> - экспоненциальный весовой коэффициент, характеризующий нечеткость;
* <math>\varepsilon > 0, ~\delta > 0</math> - коэффициенты, описывающие точность алгоритма.

Выходные данные:
* <math> M </math> - матрица принадлежности.

== Свойства алгоритма ==
*Соотношение последовательной и параллельной сложности алгоритма: <math>C*C*K \over {\log_{2} {K} + \log_{2} C^4}</math>. Соответственно при распараллеливании наибольший прирост в производительности мы получим при разбиении большого набора данных на большее число кластеров;
*Вычислительная мощность: <math>{{C^2*K} \over {C*K}} = C</math>. Получается, что на чем большее количество кластеров мы разбиваем набор данных, тем менее затратным становится перемещение данных;
*Алгоритм не является устойчивым, как и другие подобные алгоритмы этого класса(например k-means). Очень многое зависит как от входных данных, так и от изначальных параметров приближения(заполнения матрицы принадлежности => исходных центров кластеров);
*Не является детерминированным. Так же очень многое зависит как от входных данных, так и от изначальных параметров приближения(заполнения матрицы принадлежности => исходных центров кластеров);
*Алгоритм не сбалансирован - доминирует операция умножения. Параллельные ветви алгоритма сбалансированы;
*Степень исхода вершины информационного графа - 2.

= Программная реализация алгоритма =
== Особенности реализации последовательного алгоритма ==
== Локальность данных и вычислений ==
== Возможные способы и особенности параллельной реализации алгоритма ==
== Масштабируемость алгоритма и его реализации ==
== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Можно найти следующие реализации алгоритма
* Для MATLAB http://www.mathworks.com/help/fuzzy/fcm.html
* В PostgreSQL http://num-meth.srcc.msu.ru/zhurnal/tom_2012/v13r207.html
Так же готовые реализации алгоритма и его описание можно найти на сайтах
* https://habrahabr.ru/post/208496/
* http://pythonhosted.org/scikit-fuzzy/auto_examples/plot_cmeans.html
* http://www.codeproject.com/Articles/91675/Computer-Vision-Applications-with-C-Fuzzy-C-means
* https://github.com/gyaikhom/fcm

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

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

2016-10-15T20:55:40Z

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

{{Assignment}}

{{algorithm
| name = Нечеткий алгоритм C средних
| serial_complexity =
| input_data =
| output_data =
| pf_height =
| pf_width =
}}

Авторы : [[Участник:Protsenko|Мария Проценко]] (1.5-1.8, 2.7), [[Участник:ADovganich|Андрей Довганич]] (1.1-1.4, 1.9, 1.10)

= Свойства и структура алгоритмов =
== Общее описание алгоритма ==
Нечеткий алгоритм C-средних (fuzzy C-means) позволяет разбить имеющееся множество векторов (точек) мощностью K на заданное число нечетких множеств. Предназначен для кластеризации больших наборов данных. Основным достоинством алгоритма является нечеткость при определении объекта в кластер. Благодаря этому становится возможным определить объекты, которые находятся на границе, в кластеры. Из основного достоинства следует и главный недостаток - неопределенность с объектами, удаленными от центров всех кластеров. В остальном ему присущи стандартные проблемы подобного класса алгоритмов: вычислительная сложность, необходимость задания количества кластеров<ref>Нейский И.М. Классификация и сравнение методов кластеризации</ref>.

Алгоритм был разработан J.C. Dunn в 1973 г.<ref> Dunn, J. C. (1973-01-01). "A Fuzzy Relative of the ISODATA Process and Its Use in Detecting Compact Well-Separated Clusters". Journal of Cybernetics. 3 (3): 32–57. doi:10.1080/01969727308546046. ISSN 0022-0280.</ref>, усовершенствован J.C. Bezdek в 1981 г.<ref> Bezdek, James C. (1981). Pattern Recognition with Fuzzy Objective Function Algorithms. ISBN 0-306-40671-3.</ref>.

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

В общем виде алгоритм можно записать следующим образом:

# Инициализировать матрицу принадлежности;
# Вычислить центры кластеров;
# Вычислить значение решающей функции. Если значение ниже некоторого порогового или его улучшение по сравнению с предыдущей итерацией меньше определенной величины, то остановить вычисления;
# Иначе вычислить новые значения матрицы принадлежности;
# Перейти к шагу 2

== Математическое описание алгоритма ==
Рассмотрим матрицу <math> M = m_{ik} \in[0,1],\; i = 1, ..., c, \; k = 1, ..., K </math>. <math>m_{i,k}</math> - вероятность принадлежности объекта <math>k</math> к кластеру <math>i</math>; <math>c</math> - количество кластеров, <math>K</math> - количество векторов. При этом элементы матрицы удовлетворяют следующим условиям:

* сумма элементов в каждом столбце равна <math>1</math>;

* сумма всех элементов матрицы равно <math>K</math>;

Назовем <math> M </math> матрицей принадлежности.

Пусть <math>c_{i} (i = 1,2,...c)</math> - центры кластеров. Тогда рассмотрим функцию

<math>
\begin{align}
J(M, c_{1}, c_{2},...c_{c}) = \sum_{i = 1}^{c}{J_{i}} = \sum_{i = 1}^{c}\sum_{k = 1}^{K}{m_{ik}^q}d_{ik}^2 ~(1)
\end{align}
</math>

где <math> d_{ik} = \left\Vert{u_{k}-c_{i}}\right\| </math> - Евклидово расстояние между центром кластера и объектом, <math> 1 \le q \le \infty </math> - экспоненциальный весовой коэффициент, характеризующий нечеткость. Будем минимизировать значение функции <math> J </math>. Для этого вычислим центры кластеров по формуле <math> ~(2) </math>.

<math>c_{i} = {{\sum_{k = 1}^{K}{m_{ik}^q} * u_{k}} \over {\sum_{k = 1}^{K}{m_{ik}^q}}}~(2)</math>

где <math>m_{ik}</math> — коэффициент принадлежности <math>u_{k}</math> вектора к кластеру <math>c_{i}</math>

и новые значения матрицы <math> M </math> по формуле <math> ~(3) </math>

<math>m_{ik} = {1 \over \sum_{j = 1}^{c}{({{d_{ik}} \over {d_{jk}}})}^{2 \over q-1}} ~(3)</math>

<math> ~(2) </math> и <math> ~(3) </math>являются необходимым условиями достижения минимума функцией <math> J </math>. Таким образом эти два условия дают нам итерационный процесс.

Полностью алгоритм можно записать следующим образом:

# Инициализировать матрицу принадлежности <math> M </math> случайными значениями от 0 до 1;
# Вычислить центры кластеров <math>c_{i} (i = 1,2,...c)</math> используя формулу <math>~(2)</math>;
# Вычислить значение решающей функции по формуле <math>~(1)</math>. Если значение <math> J < \varepsilon,~\varepsilon > 0</math> или <math> |J_{i} - J_{i-1}| < \delta,~\delta > 0 </math>, то остановить вычисления;
# Иначе вычислить новые значения матрицы М по формуле <math>~(3)</math>;
# Перейти к шагу 2

== Вычислительное ядро алгоритма ==
Вычислительным ядром алгоритма являются формулы: <math> (1) </math>, <math> (2) </math>, <math> (3) </math>. В них производится вычисление новых центров кластеров, значения решающей функции и пересчет элементов матрицы принадлежности.

== Макроструктура алгоритма ==
Макроструктура алгоритма состоит из следующих шагов:

# Инициализация матрицы <math> M </math> случайными значениями от 0 до 1;
# Вычисление центров кластеров;
# Вычисление значения решающей функции(если оно удовлетворяет условиям останова - завершение вычислений);
# Вычисление новых элементов матрицы принадлежности;
# Переход к шагу 2;

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

Пример реализации алгоритма на языке С++
<source lang="C++">

float ** m;
int *c;
int number_clusters, number_items;
m = gen_random_clusters();//заполним матрицу m случайными значениями от 0 до 1

while (true)
{
//вычисление центров кластеров
for (int i=0; i<number_clusters; i++)
{
numerator==denumerator=0;
for (int k=0; k<number_items; k++)
{
numerator+=pow(m[i, k], q)*u[k];//u[k]-вектор
denumerator+=pow(m[i, k], q);
}
c[i]= numerator / denumerator;//центры кластеров
}

j=0;//вычисление решающей функции
for (int i=0; i<number_clusters; i++)
for (int k=0; k<number_items; k++)
j+=pow(m[i, k], q)*pow(dist(c[i], x[k],2);//dist-вычисляет расстояние между заданными векторами

if ((abs(j-last_j)<delta) || (j<eps)) break;//проверка на необходимость завернешения алгоритма
last_j=j;
//обновление матрицы m
for (int i=0; i<number_clusters; i++)
for (int k=0; k<number_items; k++)
{
m[i,k]=0
for(int j=0; j<number_clusters; j++)
m[i,k]+=pow(dist(c[i], x[k])/dist(c[j], x[k]),2/(q-1));
m[i,k]=1/m[i,k];
}

}
</source>

== Последовательная сложность алгоритма ==
Каждая итерация включает в себя
* Вычисление центров кластеров <math>O(C*K)</math>
* Вычисление решающей функции <math>O(C*K)</math>
* Обновлене матрицы <math>M</math> <math>O(C*C*K)</math>
Общая сложность каждой итерации <math>O(C*C*K)</math>.

Сложность всего алгоритма будет зависеть от числа итераций, которое зависит от
* Выбора начального приближения
* Выбора условий останова

Окончательно, сложность алгоритма будет равна произведению количества итераций на их сложность

== Информационный граф ==
'''Первый ярус''' состоит из <math>C</math> параллельных операций, каждая их которых в свою очередь состоит из <math>K</math> параллельных операций, и одной, которая выполняется с использованием результата предыдущих.
Результатом работы этого яруса являются значения центров кластеров , которые будут использоваться на следующем ярусе.

'''Второй ярус''' содержит в себе <math>C*K</math> параллельных операций.
Результатом его работы является значение решающей функции <math>J</math>. Её значение определяет необходимость завершения алгоритма.

'''Третий ярус''' включает <math>C*K</math> параллельных операций, каждая из которых состоит из <math>C</math> параллельных операций, и одной, которая выполняется с использованием результата предыдущих.

[[Файл:Снимок экрана 2016-10-15 в 23.10.05.png|582 px|thumb|center|Информационный граф]]

== Ресурс параллелизма алгоритма ==
На каждом шаге алгоритма необходимо вычислять сумму элементов массива. Сложность ее вычисления на первом шаге (вычисление центров кластеров) при параллельной реализации составляет <math>O(\log_{2} C)</math>. Для каждого элемента из набора входных данных(<math> K </math>), но здесь возможен независимый расчет(координатный параллелизм). На втором шаге(вычисление решающей функции) сложность будет <math>O(\log_{2} {C*K})</math>, потому что здесь необходимо сложение всех элементов. На третьем шаге имеем сложность <math>O(\log_{2} C^2)</math>. Итого суммарная сложность итерации: <math>O(\log_{2} {C*K} + \log_{2} C^3)</math>. Воспользовавшись свойствами логарифма произведения получаем: <math>O(\log_{2} {K} + \log_{2} C^4)</math>.

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

== Входные и выходные данные алгоритма ==
Входные данные:
* <math>u_{k} k = 1, ..., K</math> - набор входных векторов;
* <math>C</math> - количество кластеров;
* <math>q</math> - экспоненциальный весовой коэффициент, характеризующий нечеткость;
* <math>\varepsilon > 0, ~\delta > 0</math> - коэффициенты, описывающие точность алгоритма.

Выходные данные:
* <math> M </math> - матрица принадлежности.

== Свойства алгоритма ==
*Соотношение последовательной и параллельной сложности алгоритма: <math>C*C*K \over {\log_{2} {K} + \log_{2} C^4}</math>. Соответственно при распараллеливании наибольший прирост в производительности мы получим при разбиении большого набора данных на большее число кластеров;
*Вычислительная мощность: <math>{{C^2*K} \over {C*K}} = C</math>. Получается, что на чем большее количество кластеров мы разбиваем набор данных, тем менее затратным становится перемещение данных;
*Алгоритм не является устойчивым, как и другие подобные алгоритмы этого класса(например k-means). Очень многое зависит как от входных данных, так и от изначальных параметров приближения(заполнения матрицы принадлежности => исходных центров кластеров);
*Не является детерминированным. Так же очень многое зависит как от входных данных, так и от изначальных параметров приближения(заполнения матрицы принадлежности => исходных центров кластеров);
*Алгоритм не сбалансирован - доминирует операция умножения. Параллельные ветви алгоритма сбалансированы;
*Степень исхода вершины информационного графа - 2.

= Программная реализация алгоритма =
== Особенности реализации последовательного алгоритма ==
== Локальность данных и вычислений ==
== Возможные способы и особенности параллельной реализации алгоритма ==
== Масштабируемость алгоритма и его реализации ==
== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Можно найти следующие реализации алгоритма
* Для MATLAB http://www.mathworks.com/help/fuzzy/fcm.html
* В PostgreSQL http://num-meth.srcc.msu.ru/zhurnal/tom_2012/v13r207.html
Так же готовые реализации алгоритма и его описание можно найти на сайтах
* https://habrahabr.ru/post/208496/
* http://pythonhosted.org/scikit-fuzzy/auto_examples/plot_cmeans.html
* http://www.codeproject.com/Articles/91675/Computer-Vision-Applications-with-C-Fuzzy-C-means
* https://github.com/gyaikhom/fcm

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

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

2016-10-15T20:51:53Z

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

{{Assignment}}

{{algorithm
| name = Нечеткий алгоритм C средних
| serial_complexity =
| input_data =
| output_data =
| pf_height =
| pf_width =
}}

Авторы : [[Участник:Protsenko|Мария Проценко]] (1.5-1.8, 2.7), [[Участник:ADovganich|Андрей Довганич]] (1.1-1.4, 1.9, 1.10)

= Свойства и структура алгоритмов =
== Общее описание алгоритма ==
Нечеткий алгоритм C-средних (fuzzy C-means) позволяет разбить имеющееся множество векторов (точек) мощностью K на заданное число нечетких множеств. Предназначен для кластеризации больших наборов данных. Основным достоинством алгоритма является нечеткость при определении объекта в кластер. Благодаря этому становится возможным определить объекты, которые находятся на границе, в кластеры. Из основного достоинства следует и главный недостаток - неопределенность с объектами, удаленными от центров всех кластеров. В остальном ему присущи стандартные проблемы подобного класса алгоритмов: вычислительная сложность, необходимость задания количества кластеров<ref>Нейский И.М. Классификация и сравнение методов кластеризации</ref>.

Алгоритм был разработан J.C. Dunn в 1973 г.<ref> Dunn, J. C. (1973-01-01). "A Fuzzy Relative of the ISODATA Process and Its Use in Detecting Compact Well-Separated Clusters". Journal of Cybernetics. 3 (3): 32–57. doi:10.1080/01969727308546046. ISSN 0022-0280.</ref>, усовершенствован J.C. Bezdek в 1981 г.<ref> Bezdek, James C. (1981). Pattern Recognition with Fuzzy Objective Function Algorithms. ISBN 0-306-40671-3.</ref>.

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

В общем виде алгоритм можно записать следующим образом:

# Инициализировать матрицу принадлежности;
# Вычислить центры кластеров;
# Вычислить значение решающей функции. Если значение ниже некоторого порогового или его улучшение по сравнению с предыдущей итерацией меньше определенной величины, то остановить вычисления;
# Иначе вычислить новые значения матрицы принадлежности;
# Перейти к шагу 2

== Математическое описание алгоритма ==
Рассмотрим матрицу <math> M = m_{ik} \in[0,1],\; i = 1, ..., c, \; k = 1, ..., K </math>. <math>m_{i,k}</math> - вероятность принадлежности объекта <math>k</math> к кластеру <math>i</math>; <math>c</math> - количество кластеров, <math>K</math> - количество векторов. При этом элементы матрицы удовлетворяют следующим условиям:

* сумма элементов в каждом столбце равна <math>1</math>;

* сумма всех элементов матрицы равно <math>K</math>;

Назовем <math> M </math> матрицей принадлежности.

Пусть <math>c_{i} (i = 1,2,...c)</math> - центры кластеров. Тогда рассмотрим функцию

<math>
\begin{align}
J(M, c_{1}, c_{2},...c_{c}) = \sum_{i = 1}^{c}{J_{i}} = \sum_{i = 1}^{c}\sum_{k = 1}^{K}{m_{ik}^q}d_{ik}^2 ~(1)
\end{align}
</math>

где <math> d_{ik} = \left\Vert{u_{k}-c_{i}}\right\| </math> - Евклидово расстояние между центром кластера и объектом, <math> 1 \le q \le \infty </math> - экспоненциальный весовой коэффициент, характеризующий нечеткость. Будем минимизировать значение функции <math> J </math>. Для этого вычислим центры кластеров по формуле <math> ~(2) </math>.

<math>c_{i} = {{\sum_{k = 1}^{K}{m_{ik}^q} * u_{k}} \over {\sum_{k = 1}^{K}{m_{ik}^q}}}~(2)</math>

где <math>m_{ik}</math> — коэффициент принадлежности <math>u_{k}</math> вектора к кластеру <math>c_{i}</math>

и новые значения матрицы <math> M </math> по формуле <math> ~(3) </math>

<math>m_{ik} = {1 \over \sum_{j = 1}^{c}{({{d_{ik}} \over {d_{jk}}})}^{2 \over q-1}} ~(3)</math>

<math> ~(2) </math> и <math> ~(3) </math>являются необходимым условиями достижения минимума функцией <math> J </math>. Таким образом эти два условия дают нам итерационный процесс.

Полностью алгоритм можно записать следующим образом:

# Инициализировать матрицу принадлежности <math> M </math> случайными значениями от 0 до 1;
# Вычислить центры кластеров <math>c_{i} (i = 1,2,...c)</math> используя формулу <math>~(2)</math>;
# Вычислить значение решающей функции по формуле <math>~(1)</math>. Если значение <math> J < \varepsilon,~\varepsilon > 0</math> или <math> |J_{i} - J_{i-1}| < \delta,~\delta > 0 </math>, то остановить вычисления;
# Иначе вычислить новые значения матрицы М по формуле <math>~(3)</math>;
# Перейти к шагу 2

== Вычислительное ядро алгоритма ==
Вычислительным ядром алгоритма являются формулы: <math> (1) </math>, <math> (2) </math>, <math> (3) </math>. В них производится вычисление новых центров кластеров, значения решающей функции и пересчет элементов матрицы принадлежности.

== Макроструктура алгоритма ==
Макроструктура алгоритма состоит из следующих шагов:

# Инициализация матрицы <math> M </math> случайными значениями от 0 до 1;
# Вычисление центров кластеров;
# Вычисление значения решающей функции(если оно удовлетворяет условиям останова - завершение вычислений);
# Вычисление новых элементов матрицы принадлежности;
# Переход к шагу 2;

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

Пример реализации алгоритма на языке С++
<source lang="C++">

float ** m;
int *c;
int number_clusters, number_items;
m = gen_random_clusters();//заполним матрицу m случайными значениями от 0 до 1

while (true)
{
//вычисление центров кластеров
for (int i=0; i<number_clusters; i++)
{
numerator==denumerator=0;
for (int k=0; k<number_items; k++)
{
numerator+=pow(m[i, k], q)*u[k];//u[k]-вектор
denumerator+=pow(m[i, k], q);
}
c[i]= numerator / denumerator;//центры кластеров
}

j=0;//вычисление решающей функции
for (int i=0; i<number_clusters; i++)
for (int k=0; k<number_items; k++)
j+=pow(m[i, k], q)*pow(dist(c[i], x[k],2);//dist-вычисляет расстояние между заданными векторами

if ((abs(j-last_j)<delta) || (j<eps)) break;//проверка на необходимость завернешения алгоритма
last_j=j;
//обновление матрицы m
for (int i=0; i<number_clusters; i++)
for (int k=0; k<number_items; k++)
{
m[i,k]=0
for(int j=0; j<number_clusters; j++)
m[i,k]+=pow(dist(c[i], x[k])/dist(c[j], x[k]),2/(q-1));
m[i,k]=1/m[i,k];
}

}
</source>

== Последовательная сложность алгоритма ==
Каждая итерация включает в себя
* Вычисление центров кластеров <math>O(C*K)</math>
* Вычисление решающей функции <math>O(C*K)</math>
* Обновлене матрицы <math>M</math> <math>O(C*C*K)</math>
Общая сложность каждой итерации <math>O(C*C*K)</math>.

Сложность всего алгоритма будет зависеть от числа итераций, которое зависит от
* Выбора начального приближения
* Выбора условий останова

Окончательно, сложность алгоритма будет равна произведению количества итераций на их сложность

== Информационный граф ==
'''Первый ярус''' состоит из <math>C</math> параллельных операций, каждая их которых в свою очередь состоит из <math>K</math> параллельных операций, и одной, которая выполняется с использованием результата предыдущих.
Результатом работы этого яруса являются значения центров кластеров , которые будут использоваться на следующем ярусе.

'''Второй ярус''' содержит в себе <math>C*K</math> параллельных операций.
Результатом его работы является значение решающей функции <math>J</math>, значение которой влияет на необходимость завершения алгоритма.

'''Третий ярус''' включает <math>C*K</math> параллельных операций, каждая из которых состоит из <math>C</math> параллельных операций, и одной, которая выполняется с использованием результата предыдущих.

[[Файл:Снимок экрана 2016-10-15 в 23.10.05.png|582 px|thumb|center|Информационный граф]]

== Ресурс параллелизма алгоритма ==
На каждом шаге алгоритма необходимо вычислять сумму элементов массива. Её вычисление на первом шаге(вычисление центров кластеров) будет занимать при параллельной реализации <math>O(\log_{2} C)</math>. Для каждого элемента из набора входных данных(<math> K </math>), но здесь возможен независимый расчет(координатный параллелизм). На втором шаге(вычисление решающей функции) - <math>O(\log_{2} {C*K})</math>, потому что здесь необходимо сложение всех элементов. На третьем шаге имеем сложность <math>O(\log_{2} C^2)</math>. Итого суммарная сложность итерации: <math>O(\log_{2} {C*K} + \log_{2} C^3)</math>. Воспользовавшись свойствами логарифма произведения получаем: <math>O(\log_{2} {K} + \log_{2} C^4)</math>.

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

== Входные и выходные данные алгоритма ==
Входные данные:
* <math>u_{k} k = 1, ..., K</math> - набор входных векторов;
* <math>C</math> - количество кластеров;
* <math>q</math> - экспоненциальный весовой коэффициент, характеризующий нечеткость;
* <math>\varepsilon > 0, ~\delta > 0</math> - коэффициенты, описывающие точность алгоритма.

Выходные данные:
* <math> M </math> - матрица принадлежности.

== Свойства алгоритма ==
*Соотношение последовательной и параллельной сложности алгоритма: <math>C*C*K \over {\log_{2} {K} + \log_{2} C^4}</math>. Соответственно при распараллеливании наибольший прирост в производительности мы получим при разбиении большого набора данных на большее число кластеров;
*Вычислительная мощность: <math>{{C^2*K} \over {C*K}} = C</math>. Получается, что на чем большее количество кластеров мы разбиваем набор данных, тем менее затратным становится перемещение данных;
*Алгоритм не является устойчивым, как и другие подобные алгоритмы этого класса(например k-means). Очень многое зависит как от входных данных, так и от изначальных параметров приближения(заполнения матрицы принадлежности => исходных центров кластеров);
*Не является детерминированным. Так же очень многое зависит как от входных данных, так и от изначальных параметров приближения(заполнения матрицы принадлежности => исходных центров кластеров);
*Алгоритм не сбалансирован - доминирует операция умножения. Параллельные ветви алгоритма сбалансированы;
*Степень исхода вершины информационного графа - 2.

= Программная реализация алгоритма =
== Особенности реализации последовательного алгоритма ==
== Локальность данных и вычислений ==
== Возможные способы и особенности параллельной реализации алгоритма ==
== Масштабируемость алгоритма и его реализации ==
== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Можно найти следующие реализации алгоритма
* Для MATLAB http://www.mathworks.com/help/fuzzy/fcm.html
* В PostgreSQL http://num-meth.srcc.msu.ru/zhurnal/tom_2012/v13r207.html
Так же готовые реализации алгоритма и его описание можно найти на сайтах
* https://habrahabr.ru/post/208496/
* http://pythonhosted.org/scikit-fuzzy/auto_examples/plot_cmeans.html
* http://www.codeproject.com/Articles/91675/Computer-Vision-Applications-with-C-Fuzzy-C-means
* https://github.com/gyaikhom/fcm

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

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

2016-10-15T20:46:12Z

Protsenko:

{{Assignment}}

{{algorithm
| name = Нечеткий алгоритм C средних
| serial_complexity =
| input_data =
| output_data =
| pf_height =
| pf_width =
}}

Авторы : [[Участник:Protsenko|Мария Проценко]] (1.5-1.8, 1.10, 2.7), [[Участник:ADovganich|Андрей Довганич]] (1.1-1.4, 1.9)

= Свойства и структура алгоритмов =
== Общее описание алгоритма ==
Нечеткий алгоритм C-средних (fuzzy C-means) позволяет разбить имеющееся множество векторов (точек) мощностью K на заданное число нечетких множеств. Предназначен для кластеризации больших наборов данных. Основным достоинством алгоритма является нечеткость при определении объекта в кластер. Благодаря этому становится возможным определить объекты, которые находятся на границе, в кластеры. Из основного достоинства следует и главный недостаток - неопределенность с объектами, удаленными от центров всех кластеров. В остальном ему присущи стандартные проблемы подобного класса алгоритмов: вычислительная сложность, необходимость задания количества кластеров<ref>Нейский И.М. Классификация и сравнение методов кластеризации</ref>.

Алгоритм был разработан J.C. Dunn в 1973 г.<ref> Dunn, J. C. (1973-01-01). "A Fuzzy Relative of the ISODATA Process and Its Use in Detecting Compact Well-Separated Clusters". Journal of Cybernetics. 3 (3): 32–57. doi:10.1080/01969727308546046. ISSN 0022-0280.</ref>, усовершенствован J.C. Bezdek в 1981 г.<ref> Bezdek, James C. (1981). Pattern Recognition with Fuzzy Objective Function Algorithms. ISBN 0-306-40671-3.</ref>.

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

В общем виде алгоритм можно записать следующим образом:

# Инициализировать матрицу принадлежности;
# Вычислить центры кластеров;
# Вычислить значение решающей функции. Если значение ниже некоторого порогового или его улучшение по сравнению с предыдущей итерацией меньше определенной величины, то остановить вычисления;
# Иначе вычислить новые значения матрицы принадлежности;
# Перейти к шагу 2

== Математическое описание алгоритма ==
Рассмотрим матрицу <math> M = m_{ik} \in[0,1],\; i = 1, ..., c, \; k = 1, ..., K </math>. <math>m_{i,k}</math> - вероятность принадлежности объекта <math>k</math> к кластеру <math>i</math>; <math>c</math> - количество кластеров, <math>K</math> - количество векторов. При этом элементы матрицы удовлетворяют следующим условиям:

* сумма элементов в каждом столбце равна <math>1</math>;

* сумма всех элементов матрицы равно <math>K</math>;

Назовем <math> M </math> матрицей принадлежности.

Пусть <math>c_{i} (i = 1,2,...c)</math> - центры кластеров. Тогда рассмотрим функцию

<math>
\begin{align}
J(M, c_{1}, c_{2},...c_{c}) = \sum_{i = 1}^{c}{J_{i}} = \sum_{i = 1}^{c}\sum_{k = 1}^{K}{m_{ik}^q}d_{ik}^2 ~(1)
\end{align}
</math>

где <math> d_{ik} = \left\Vert{u_{k}-c_{i}}\right\| </math> - Евклидово расстояние между центром кластера и объектом, <math> 1 \le q \le \infty </math> - экспоненциальный весовой коэффициент, характеризующий нечеткость. Будем минимизировать значение функции <math> J </math>. Для этого вычислим центры кластеров по формуле <math> ~(2) </math>.

<math>c_{i} = {{\sum_{k = 1}^{K}{m_{ik}^q} * u_{k}} \over {\sum_{k = 1}^{K}{m_{ik}^q}}}~(2)</math>

где <math>m_{ik}</math> — коэффициент принадлежности <math>u_{k}</math> вектора к кластеру <math>c_{i}</math>

и новые значения матрицы <math> M </math> по формуле <math> ~(3) </math>

<math>m_{ik} = {1 \over \sum_{j = 1}^{c}{({{d_{ik}} \over {d_{jk}}})}^{2 \over q-1}} ~(3)</math>

<math> ~(2) </math> и <math> ~(3) </math>являются необходимым условиями достижения минимума функцией <math> J </math>. Таким образом эти два условия дают нам итерационный процесс.

Полностью алгоритм можно записать следующим образом:

# Инициализировать матрицу принадлежности <math> M </math> случайными значениями от 0 до 1;
# Вычислить центры кластеров <math>c_{i} (i = 1,2,...c)</math> используя формулу <math>~(2)</math>;
# Вычислить значение решающей функции по формуле <math>~(1)</math>. Если значение <math> J < \varepsilon,~\varepsilon > 0</math> или <math> |J_{i} - J_{i-1}| < \delta,~\delta > 0 </math>, то остановить вычисления;
# Иначе вычислить новые значения матрицы М по формуле <math>~(3)</math>;
# Перейти к шагу 2

== Вычислительное ядро алгоритма ==
Вычислительным ядром алгоритма являются формулы: <math> (1) </math>, <math> (2) </math>, <math> (3) </math>. В них производится вычисление новых центров кластеров, значения решающей функции и пересчет элементов матрицы принадлежности.

== Макроструктура алгоритма ==
Макроструктура алгоритма состоит из следующих шагов:

# Инициализация матрицы <math> M </math> случайными значениями от 0 до 1;
# Вычисление центров кластеров;
# Вычисление значения решающей функции(если оно удовлетворяет условиям останова - завершение вычислений);
# Вычисление новых элементов матрицы принадлежности;
# Переход к шагу 2;

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

Пример реализации алгоритма на языке С++
<source lang="C++">

float ** m;
int *c;
int number_clusters, number_items;
m = gen_random_clusters();//заполним матрицу m случайными значениями от 0 до 1

while (true)
{
//вычисление центров кластеров
for (int i=0; i<number_clusters; i++)
{
numerator==denumerator=0;
for (int k=0; k<number_items; k++)
{
numerator+=pow(m[i, k], q)*u[k];//u[k]-вектор
denumerator+=pow(m[i, k], q);
}
c[i]= numerator / denumerator;//центры кластеров
}

j=0;//вычисление решающей функции
for (int i=0; i<number_clusters; i++)
for (int k=0; k<number_items; k++)
j+=pow(m[i, k], q)*pow(dist(c[i], x[k],2);//dist-вычисляет расстояние между заданными векторами

if ((abs(j-last_j)<delta) || (j<eps)) break;//проверка на необходимость завернешения алгоритма
last_j=j;
//обновление матрицы m
for (int i=0; i<number_clusters; i++)
for (int k=0; k<number_items; k++)
{
m[i,k]=0
for(int j=0; j<number_clusters; j++)
m[i,k]+=pow(dist(c[i], x[k])/dist(c[j], x[k]),2/(q-1));
m[i,k]=1/m[i,k];
}

}
</source>

== Последовательная сложность алгоритма ==
Каждая итерация включает в себя
* Вычисление центров кластеров <math>O(C*K)</math>
* Вычисление решающей функции <math>O(C*K)</math>
* Обновлене матрицы <math>M</math> <math>O(C*C*K)</math>
Общая сложность каждой итерации <math>O(C*C*K)</math>.

Сложность всего алгоритма будет зависеть от числа итераций, которое зависит от
* Выбора начального приближения
* Выбора условий останова

Окончательно, сложность алгоритма будет равна произведению количества итераций на их сложность

== Информационный граф ==
'''Первый ярус''' состоит из <math>C</math> параллельных операций, каждая их которых в свою очередь состоит из <math>K</math> параллельных операций, и одной, которая выполняется с использованием результата предыдущих.
Результатом работы этого яруса является значение <math>C</math> , которое будет использоваться на следующем ярусе.

'''Второй ярус''' содержит в себе <math>C*K</math> параллельных операций.
Результатом его работы является значение решающей функции <math>J</math>, значение которой влияет на необходимость завершения алгоритма.

'''Третий ярус''' включает <math>C*K</math> параллельных операций, каждая из которых состоит из <math>C</math> параллельных операций, и одной, которая выполняется с использованием результата предыдущих.

[[Файл:Снимок экрана 2016-10-15 в 23.10.05.png|582 px|thumb|center|Информационный граф]]

== Ресурс параллелизма алгоритма ==
На каждом шаге алгоритма необходимо вычислять сумму элементов массива. Её вычисление на первом шаге(вычисление центров кластеров) будет занимать при параллельной реализации <math>O(\log_{2} C)</math>. Для каждого элемента из набора входных данных(<math> K </math>), но здесь возможен независимый расчет(координатный параллелизм). На втором шаге(вычисление решающей функции) - <math>O(\log_{2} {C*K})</math>, потому что здесь необходимо сложение всех элементов. На третьем шаге имеем сложность <math>O(\log_{2} C^2)</math>. Итого суммарная сложность итерации: <math>O(\log_{2} {C*K} + \log_{2} C^3)</math>. Воспользовавшись свойствами логарифма произведения получаем: <math>O(\log_{2} {K} + \log_{2} C^4)</math>.

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

== Входные и выходные данные алгоритма ==
Входные данные:
* <math>u_{k} k = 1, ..., K</math> - набор входных векторов;
* <math>C</math> - количество кластеров;
* <math>q</math> - экспоненциальный весовой коэффициент, характеризующий нечеткость;
* <math>\varepsilon > 0, ~\delta > 0</math> - коэффициенты, описывающие точность алгоритма.

Выходные данные:
* <math> M </math> - матрица принадлежности.

== Свойства алгоритма ==
*Соотношение последовательной и параллельной сложности алгоритма: <math>C*C*K \over {\log_{2} {K} + \log_{2} C^4}</math>. Соответственно при распараллеливании наибольший прирост в производительности мы получим при разбиении большого набора данных на большее число кластеров;
*Вычислительная мощность: <math>{{C^2*K} \over {C*K}} = C</math>. Получается, что на чем большее количество кластеров мы разбиваем набор данных, тем менее затратным становится перемещение данных;
*Алгоритм не является устойчивым, как и другие подобные алгоритмы этого класса(например k-means). Очень многое зависит как от входных данных, так и от изначальных параметров приближения(заполнения матрицы принадлежности => исходных центров кластеров);
*Не является детерминированным. Так же очень многое зависит как от входных данных, так и от изначальных параметров приближения(заполнения матрицы принадлежности => исходных центров кластеров);
*Алгоритм не сбалансирован - доминирует операция умножения. Параллельные ветви алгоритма сбалансированы;
*Степень исхода вершины информационного графа - 2.

= Программная реализация алгоритма =
== Особенности реализации последовательного алгоритма ==
== Локальность данных и вычислений ==
== Возможные способы и особенности параллельной реализации алгоритма ==
== Масштабируемость алгоритма и его реализации ==
== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Можно найти следующие реализации алгоритма
* Для MATLAB http://www.mathworks.com/help/fuzzy/fcm.html
* В PostgreSQL http://num-meth.srcc.msu.ru/zhurnal/tom_2012/v13r207.html
Так же готовые реализации алгоритма и его описание можно найти на сайтах
* https://habrahabr.ru/post/208496/
* http://pythonhosted.org/scikit-fuzzy/auto_examples/plot_cmeans.html
* http://www.codeproject.com/Articles/91675/Computer-Vision-Applications-with-C-Fuzzy-C-means
* https://github.com/gyaikhom/fcm

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

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

2016-10-15T20:44:41Z

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

{{algorithm
| name = Нечеткий алгоритм C средних
| serial_complexity =
| input_data =
| output_data =
| pf_height =
| pf_width =
}}

Авторы : [[Участник:Protsenko|Мария Проценко]] (1.5-1.8, 1.10, 2.7), [[Участник:ADovganich|Андрей Довганич]] (1.1-1.4, 1.9)

= Свойства и структура алгоритмов =
== Общее описание алгоритма ==
Нечеткий алгоритм C-средних (fuzzy C-means) позволяет разбить имеющееся множество векторов (точек) мощностью K на заданное число нечетких множеств. Предназначен для кластеризации больших наборов данных. Основным достоинством алгоритма является нечеткость при определении объекта в кластер. Благодаря этому становится возможным определить объекты, которые находятся на границе, в кластеры. Из основного достоинства следует и главный недостаток - неопределенность с объектами, удаленными от центров всех кластеров. В остальном ему присущи стандартные проблемы подобного класса алгоритмов: вычислительная сложность, необходимость задания количества кластеров<ref>Нейский И.М. Классификация и сравнение методов кластеризации</ref>.

Алгоритм был разработан J.C. Dunn в 1973 г.<ref> Dunn, J. C. (1973-01-01). "A Fuzzy Relative of the ISODATA Process and Its Use in Detecting Compact Well-Separated Clusters". Journal of Cybernetics. 3 (3): 32–57. doi:10.1080/01969727308546046. ISSN 0022-0280.</ref>, усовершенствован J.C. Bezdek в 1981 г.<ref> Bezdek, James C. (1981). Pattern Recognition with Fuzzy Objective Function Algorithms. ISBN 0-306-40671-3.</ref>.

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

В общем виде алгоритм можно записать следующим образом:

# Инициализировать матрицу принадлежности;
# Вычислить центры кластеров;
# Вычислить значение решающей функции. Если значение ниже некоторого порогового или его улучшение по сравнению с предыдущей итерацией меньше определенной величины, то остановить вычисления;
# Иначе вычислить новые значения матрицы принадлежности;
# Перейти к шагу 2

== Математическое описание алгоритма ==
Рассмотрим матрицу <math> M = m_{ik} \in[0,1],\; i = 1, ..., c, \; k = 1, ..., K </math>. <math>m_{i,k}</math> - вероятность принадлежности объекта <math>k</math> к кластеру <math>i</math>; <math>c</math> - количество кластеров, <math>K</math> - количество векторов. При этом элементы матрицы удовлетворяют следующим условиям:

* сумма элементов в каждом столбце равна <math>1</math>;

* сумма всех элементов матрицы равно <math>K</math>;

Назовем <math> M </math> матрицей принадлежности.

Пусть <math>c_{i} (i = 1,2,...c)</math> - центры кластеров. Тогда рассмотрим функцию

<math>
\begin{align}
J(M, c_{1}, c_{2},...c_{c}) = \sum_{i = 1}^{c}{J_{i}} = \sum_{i = 1}^{c}\sum_{k = 1}^{K}{m_{ik}^q}d_{ik}^2 ~(1)
\end{align}
</math>

где <math> d_{ik} = \left\Vert{u_{k}-c_{i}}\right\| </math> - Евклидово расстояние между центром кластера и объектом, <math> 1 \le q \le \infty </math> - экспоненциальный весовой коэффициент, характеризующий нечеткость. Будем минимизировать значение функции <math> J </math>. Для этого вычислим центры кластеров по формуле <math> ~(2) </math>.

<math>c_{i} = {{\sum_{k = 1}^{K}{m_{ik}^q} * u_{k}} \over {\sum_{k = 1}^{K}{m_{ik}^q}}}~(2)</math>

где <math>m_{ik}</math> — коэффициент принадлежности <math>u_{k}</math> вектора к кластеру <math>c_{i}</math>

и новые значения матрицы <math> M </math> по формуле <math> ~(3) </math>

<math>m_{ik} = {1 \over \sum_{j = 1}^{c}{({{d_{ik}} \over {d_{jk}}})}^{2 \over q-1}} ~(3)</math>

<math> ~(2) </math> и <math> ~(3) </math>являются необходимым условиями достижения минимума функцией <math> J </math>. Таким образом эти два условия дают нам итерационный процесс.

Полностью алгоритм можно записать следующим образом:

# Инициализировать матрицу принадлежности <math> M </math> случайными значениями от 0 до 1;
# Вычислить центры кластеров <math>c_{i} (i = 1,2,...c)</math> используя формулу <math>~(2)</math>;
# Вычислить значение решающей функции по формуле <math>~(1)</math>. Если значение <math> J < \varepsilon,~\varepsilon > 0</math> или <math> |J_{i} - J_{i-1}| < \delta,~\delta > 0 </math>, то остановить вычисления;
# Иначе вычислить новые значения матрицы М по формуле <math>~(3)</math>;
# Перейти к шагу 2

== Вычислительное ядро алгоритма ==
Вычислительным ядром алгоритма являются формулы: <math> (1) </math>, <math> (2) </math>, <math> (3) </math>. В них производится вычисление новых центров кластеров, значения решающей функции и пересчет элементов матрицы принадлежности.

== Макроструктура алгоритма ==
Макроструктура алгоритма состоит из следующих шагов:

# Инициализация матрицы <math> M </math> случайными значениями от 0 до 1;
# Вычисление центров кластеров;
# Вычисление значения решающей функции(если оно удовлетворяет условиям останова - завершение вычислений);
# Вычисление новых элементов матрицы принадлежности;
# Переход к шагу 2;

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

Пример реализации алгоритма на языке С++
<source lang="C++">

float ** m;
int *c;
int number_clusters, number_items;
m = gen_random_clusters();//заполним матрицу m случайными значениями от 0 до 1

while (true)
{
//вычисление центров кластеров
for (int i=0; i<number_clusters; i++)
{
numerator==denumerator=0;
for (int k=0; k<number_items; k++)
{
numerator+=pow(m[i, k], q)*u[k];//u[k]-вектор
denumerator+=pow(m[i, k], q);
}
c[i]= numerator / denumerator;//центры кластеров
}

j=0;//вычисление решающей функции
for (int i=0; i<number_clusters; i++)
for (int k=0; k<number_items; k++)
j+=pow(m[i, k], q)*pow(dist(c[i], x[k],2);//dist-вычисляет расстояние между заданными векторами

if ((abs(j-last_j)<delta) || (j<eps)) break;//проверка на необходимость завернешения алгоритма
last_j=j;
//обновление матрицы m
for (int i=0; i<number_clusters; i++)
for (int k=0; k<number_items; k++)
{
m[i,k]=0
for(int j=0; j<number_clusters; j++)
m[i,k]+=pow(dist(c[i], x[k])/dist(c[j], x[k]),2/(q-1));
m[i,k]=1/m[i,k];
}

}
</source>

== Последовательная сложность алгоритма ==
Каждая итерация включает в себя
* Вычисление центров кластеров <math>O(C*K)</math>
* Вычисление решающей функции <math>O(C*K)</math>
* Обновлене матрицы <math>M</math> <math>O(C*C*K)</math>
Общая сложность каждой итерации <math>O(C*C*K)</math>.

Сложность всего алгоритма будет зависеть от числа итераций, которое зависит от
* Выбора начального приближения
* Выбора условий останова

Окончательно, сложность алгоритма будет равна произведению количества итераций на их сложность

== Информационный граф ==
'''Первый ярус''' состоит из <math>C</math> параллельных операций, каждая их которых в свою очередь состоит из <math>K</math> параллельных операций, и одной, которая выполняется с использованием результата предыдущих.
Результатом работы этого яруса является значение <math>C</math> , которое будет использоваться на следующем ярусе.

'''Второй ярус''' содержит в себе <math>C*K</math> параллельных операций.
Результатом его работы является значение решающей функции <math>J</math>, значение которой влияет на необходимость завершения алгоритма.

'''Третий ярус''' включает <math>C*K</math> параллельных операций, каждая из которых состоит из <math>C</math> параллельных операций, и одной, которая выполняется с использованием результата предыдущих.

[[Файл:Снимок экрана 2016-10-15 в 23.10.05.png|582 px|thumb|center|Информационный граф]]

== Ресурс параллелизма алгоритма ==
На каждом шаге алгоритма необходимо вычислять сумму элементов массива. Её вычисление на первом шаге(вычисление центров кластеров) будет занимать при параллельной реализации <math>O(\log_{2} C)</math>. Для каждого элемента из набора входных данных(<math> K </math>), но здесь возможен независимый расчет(координатный параллелизм). На втором шаге(вычисление решающей функции) - <math>O(\log_{2} {C*K})</math>, потому что здесь необходимо сложение всех элементов. На третьем шаге имеем сложность <math>O(\log_{2} C^2)</math>. Итого суммарная сложность итерации: <math>O(\log_{2} {C*K} + \log_{2} C^3)</math>. Воспользовавшись свойствами логарифма произведения получаем: <math>O(\log_{2} {K} + \log_{2} C^4)</math>.

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

== Входные и выходные данные алгоритма ==
Входные данные:
* <math>u_{k} k = 1, ..., K</math> - набор входных векторов;
* <math>C</math> - количество кластеров;
* <math>q</math> - экспоненциальный весовой коэффициент, характеризующий нечеткость;
* <math>\varepsilon > 0, ~\delta > 0</math> - коэффициенты, описывающие точность алгоритма.

Выходные данные:
* <math> M </math> - матрица принадлежности.

== Свойства алгоритма ==
*Соотношение последовательной и параллельной сложности алгоритма: <math>C*C*K \over {\log_{2} {K} + \log_{2} C^4}</math>. Соответственно при распараллеливании наибольший прирост в производительности мы получим при разбиении большого набора данных на большее число кластеров;
*Вычислительная мощность: <math>{{C^2*K} \over {C*K}} = C</math>. Получается, что на чем большее количество кластеров мы разбиваем набор данных, тем менее затратным становится перемещение данных;
*Алгоритм не является устойчивым, как и другие подобные алгоритмы этого класса(например k-means). Очень многое зависит как от входных данных, так и от изначальных параметров приближения(заполнения матрицы принадлежности => исходных центров кластеров);
*Не является детерминированным. Так же очень многое зависит как от входных данных, так и от изначальных параметров приближения(заполнения матрицы принадлежности => исходных центров кластеров);
*Алгоритм не сбалансирован - доминирует операция умножения. Параллельные ветви алгоритма сбалансированы;
*Степень исхода вершины информационного графа - 2.

= Программная реализация алгоритма =
== Особенности реализации последовательного алгоритма ==
== Локальность данных и вычислений ==
== Возможные способы и особенности параллельной реализации алгоритма ==
== Масштабируемость алгоритма и его реализации ==
== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Можно найти следующие реализации алгоритма
* Для MATLAB http://www.mathworks.com/help/fuzzy/fcm.html
* В PostgreSQL http://num-meth.srcc.msu.ru/zhurnal/tom_2012/v13r207.html
Так же готовые реализации алгоритма и его описание можно найти на сайтах
* https://habrahabr.ru/post/208496/
* http://pythonhosted.org/scikit-fuzzy/auto_examples/plot_cmeans.html
* http://www.codeproject.com/Articles/91675/Computer-Vision-Applications-with-C-Fuzzy-C-means
* https://github.com/gyaikhom/fcm

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

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

2016-10-15T20:43:44Z

Protsenko: /* Макроструктура алгоритма */

{{algorithm
| name = Нечеткий алгоритм C средних
| serial_complexity =
| input_data =
| output_data =
| pf_height =
| pf_width =
}}

Авторы : [[Участник:Protsenko|Мария Проценко]] (1.5-1.8, 1.10, 2.7), [[Участник:ADovganich|Андрей Довганич]] (1.1-1.4, 1.9)

= Свойства и структура алгоритмов =
== Общее описание алгоритма ==
Нечеткий алгоритм C-средних (fuzzy C-means) позволяет разбить имеющееся множество векторов (точек) мощностью p на заданное число нечетких множеств. Предназначен для кластеризации больших наборов данных. Основным достоинством алгоритма является нечеткость при определении объекта в кластер. Благодаря этому становится возможным определить объекты, которые находятся на границе, в кластеры. Из основного достоинства следует и главный недостаток - неопределенность с объектами, удаленными от центров всех кластеров. В остальном ему присущи стандартные проблемы подобного класса алгоритмов: вычислительная сложность, необходимость задания количества кластеров<ref>Нейский И.М. Классификация и сравнение методов кластеризации</ref>.

Алгоритм был разработан J.C. Dunn в 1973 г.<ref> Dunn, J. C. (1973-01-01). "A Fuzzy Relative of the ISODATA Process and Its Use in Detecting Compact Well-Separated Clusters". Journal of Cybernetics. 3 (3): 32–57. doi:10.1080/01969727308546046. ISSN 0022-0280.</ref>, усовершенствован J.C. Bezdek в 1981 г.<ref> Bezdek, James C. (1981). Pattern Recognition with Fuzzy Objective Function Algorithms. ISBN 0-306-40671-3.</ref>.

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

В общем виде алгоритм можно записать следующим образом:

# Инициализировать матрицу принадлежности;
# Вычислить центры кластеров;
# Вычислить значение решающей функции. Если значение ниже некоторого порогового или его улучшение по сравнению с предыдущей итерацией меньше определенной величины, то остановить вычисления;
# Иначе вычислить новые значения матрицы принадлежности;
# Перейти к шагу 2

== Математическое описание алгоритма ==
Рассмотрим матрицу <math> M = m_{ik} \in[0,1],\; i = 1, ..., c, \; k = 1, ..., K </math>. <math>m_{i,k}</math> - вероятность принадлежности объекта <math>k</math> к кластеру <math>i</math>; <math>c</math> - количество кластеров, <math>K</math> - количество векторов. При этом элементы матрицы удовлетворяют следующим условиям:

* сумма элементов в каждом столбце равна <math>1</math>;

* сумма всех элементов матрицы равно <math>K</math>;

Назовем <math> M </math> матрицей принадлежности.

Пусть <math>c_{i} (i = 1,2,...c)</math> - центры кластеров. Тогда рассмотрим функцию

<math>
\begin{align}
J(M, c_{1}, c_{2},...c_{c}) = \sum_{i = 1}^{c}{J_{i}} = \sum_{i = 1}^{c}\sum_{k = 1}^{K}{m_{ik}^q}d_{ik}^2 ~(1)
\end{align}
</math>

где <math> d_{ik} = \left\Vert{u_{k}-c_{i}}\right\| </math> - Евклидово расстояние между центром кластера и объектом, <math> 1 \le q \le \infty </math> - экспоненциальный весовой коэффициент, характеризующий нечеткость. Будем минимизировать значение функции <math> J </math>. Для этого вычислим центры кластеров по формуле <math> ~(2) </math>.

<math>c_{i} = {{\sum_{k = 1}^{K}{m_{ik}^q} * u_{k}} \over {\sum_{k = 1}^{K}{m_{ik}^q}}}~(2)</math>

где <math>m_{ik}</math> — коэффициент принадлежности <math>u_{k}</math> вектора к кластеру <math>c_{i}</math>

и новые значения матрицы <math> M </math> по формуле <math> ~(3) </math>

<math>m_{ik} = {1 \over \sum_{j = 1}^{c}{({{d_{ik}} \over {d_{jk}}})}^{2 \over q-1}} ~(3)</math>

<math> ~(2) </math> и <math> ~(3) </math>являются необходимым условиями достижения минимума функцией <math> J </math>. Таким образом эти два условия дают нам итерационный процесс.

Полностью алгоритм можно записать следующим образом:

# Инициализировать матрицу принадлежности <math> M </math> случайными значениями от 0 до 1;
# Вычислить центры кластеров <math>c_{i} (i = 1,2,...c)</math> используя формулу <math>~(2)</math>;
# Вычислить значение решающей функции по формуле <math>~(1)</math>. Если значение <math> J < \varepsilon,~\varepsilon > 0</math> или <math> |J_{i} - J_{i-1}| < \delta,~\delta > 0 </math>, то остановить вычисления;
# Иначе вычислить новые значения матрицы М по формуле <math>~(3)</math>;
# Перейти к шагу 2

== Вычислительное ядро алгоритма ==
Вычислительным ядром алгоритма являются формулы: <math> (1) </math>, <math> (2) </math>, <math> (3) </math>. В них производится вычисление новых центров кластеров, значения решающей функции и пересчет элементов матрицы принадлежности.

== Макроструктура алгоритма ==
Макроструктура алгоритма состоит из следующих шагов:

# Инициализация матрицы <math> M </math> случайными значениями от 0 до 1;
# Вычисление центров кластеров;
# Вычисление значения решающей функции(если оно удовлетворяет условиям останова - завершение вычислений);
# Вычисление новых элементов матрицы принадлежности;
# Переход к шагу 2;

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

Пример реализации алгоритма на языке С++
<source lang="C++">

float ** m;
int *c;
int number_clusters, number_items;
m = gen_random_clusters();//заполним матрицу m случайными значениями от 0 до 1

while (true)
{
//вычисление центров кластеров
for (int i=0; i<number_clusters; i++)
{
numerator==denumerator=0;
for (int k=0; k<number_items; k++)
{
numerator+=pow(m[i, k], q)*u[k];//u[k]-вектор
denumerator+=pow(m[i, k], q);
}
c[i]= numerator / denumerator;//центры кластеров
}

j=0;//вычисление решающей функции
for (int i=0; i<number_clusters; i++)
for (int k=0; k<number_items; k++)
j+=pow(m[i, k], q)*pow(dist(c[i], x[k],2);//dist-вычисляет расстояние между заданными векторами

if ((abs(j-last_j)<delta) || (j<eps)) break;//проверка на необходимость завернешения алгоритма
last_j=j;
//обновление матрицы m
for (int i=0; i<number_clusters; i++)
for (int k=0; k<number_items; k++)
{
m[i,k]=0
for(int j=0; j<number_clusters; j++)
m[i,k]+=pow(dist(c[i], x[k])/dist(c[j], x[k]),2/(q-1));
m[i,k]=1/m[i,k];
}

}
</source>

== Последовательная сложность алгоритма ==
Каждая итерация включает в себя
* Вычисление центров кластеров <math>O(C*K)</math>
* Вычисление решающей функции <math>O(C*K)</math>
* Обновлене матрицы <math>M</math> <math>O(C*C*K)</math>
Общая сложность каждой итерации <math>O(C*C*K)</math>.

Сложность всего алгоритма будет зависеть от числа итераций, которое зависит от
* Выбора начального приближения
* Выбора условий останова

Окончательно, сложность алгоритма будет равна произведению количества итераций на их сложность

== Информационный граф ==
'''Первый ярус''' состоит из <math>C</math> параллельных операций, каждая их которых в свою очередь состоит из <math>K</math> параллельных операций, и одной, которая выполняется с использованием результата предыдущих.
Результатом работы этого яруса является значение <math>C</math> , которое будет использоваться на следующем ярусе.

'''Второй ярус''' содержит в себе <math>C*K</math> параллельных операций.
Результатом его работы является значение решающей функции <math>J</math>, значение которой влияет на необходимость завершения алгоритма.

'''Третий ярус''' включает <math>C*K</math> параллельных операций, каждая из которых состоит из <math>C</math> параллельных операций, и одной, которая выполняется с использованием результата предыдущих.

[[Файл:Снимок экрана 2016-10-15 в 23.10.05.png|582 px|thumb|center|Информационный граф]]

== Ресурс параллелизма алгоритма ==
На каждом шаге алгоритма необходимо вычислять сумму элементов массива. Её вычисление на первом шаге(вычисление центров кластеров) будет занимать при параллельной реализации <math>O(\log_{2} C)</math>. Для каждого элемента из набора входных данных(<math> K </math>), но здесь возможен независимый расчет(координатный параллелизм). На втором шаге(вычисление решающей функции) - <math>O(\log_{2} {C*K})</math>, потому что здесь необходимо сложение всех элементов. На третьем шаге имеем сложность <math>O(\log_{2} C^2)</math>. Итого суммарная сложность итерации: <math>O(\log_{2} {C*K} + \log_{2} C^3)</math>. Воспользовавшись свойствами логарифма произведения получаем: <math>O(\log_{2} {K} + \log_{2} C^4)</math>.

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

== Входные и выходные данные алгоритма ==
Входные данные:
* <math>u_{k} k = 1, ..., K</math> - набор входных векторов;
* <math>C</math> - количество кластеров;
* <math>q</math> - экспоненциальный весовой коэффициент, характеризующий нечеткость;
* <math>\varepsilon > 0, ~\delta > 0</math> - коэффициенты, описывающие точность алгоритма.

Выходные данные:
* <math> M </math> - матрица принадлежности.

== Свойства алгоритма ==
*Соотношение последовательной и параллельной сложности алгоритма: <math>C*C*K \over {\log_{2} {K} + \log_{2} C^4}</math>. Соответственно при распараллеливании наибольший прирост в производительности мы получим при разбиении большого набора данных на большее число кластеров;
*Вычислительная мощность: <math>{{C^2*K} \over {C*K}} = C</math>. Получается, что на чем большее количество кластеров мы разбиваем набор данных, тем менее затратным становится перемещение данных;
*Алгоритм не является устойчивым, как и другие подобные алгоритмы этого класса(например k-means). Очень многое зависит как от входных данных, так и от изначальных параметров приближения(заполнения матрицы принадлежности => исходных центров кластеров);
*Не является детерминированным. Так же очень многое зависит как от входных данных, так и от изначальных параметров приближения(заполнения матрицы принадлежности => исходных центров кластеров);
*Алгоритм не сбалансирован - доминирует операция умножения. Параллельные ветви алгоритма сбалансированы;
*Степень исхода вершины информационного графа - 2.

= Программная реализация алгоритма =
== Особенности реализации последовательного алгоритма ==
== Локальность данных и вычислений ==
== Возможные способы и особенности параллельной реализации алгоритма ==
== Масштабируемость алгоритма и его реализации ==
== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Можно найти следующие реализации алгоритма
* Для MATLAB http://www.mathworks.com/help/fuzzy/fcm.html
* В PostgreSQL http://num-meth.srcc.msu.ru/zhurnal/tom_2012/v13r207.html
Так же готовые реализации алгоритма и его описание можно найти на сайтах
* https://habrahabr.ru/post/208496/
* http://pythonhosted.org/scikit-fuzzy/auto_examples/plot_cmeans.html
* http://www.codeproject.com/Articles/91675/Computer-Vision-Applications-with-C-Fuzzy-C-means
* https://github.com/gyaikhom/fcm

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

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

2016-10-15T20:43:12Z

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

{{algorithm
| name = Нечеткий алгоритм C средних
| serial_complexity =
| input_data =
| output_data =
| pf_height =
| pf_width =
}}

Авторы : [[Участник:Protsenko|Мария Проценко]] (1.5-1.8, 1.10, 2.7), [[Участник:ADovganich|Андрей Довганич]] (1.1-1.4, 1.9)

= Свойства и структура алгоритмов =
== Общее описание алгоритма ==
Нечеткий алгоритм C-средних (fuzzy C-means) позволяет разбить имеющееся множество векторов (точек) мощностью p на заданное число нечетких множеств. Предназначен для кластеризации больших наборов данных. Основным достоинством алгоритма является нечеткость при определении объекта в кластер. Благодаря этому становится возможным определить объекты, которые находятся на границе, в кластеры. Из основного достоинства следует и главный недостаток - неопределенность с объектами, удаленными от центров всех кластеров. В остальном ему присущи стандартные проблемы подобного класса алгоритмов: вычислительная сложность, необходимость задания количества кластеров<ref>Нейский И.М. Классификация и сравнение методов кластеризации</ref>.

Алгоритм был разработан J.C. Dunn в 1973 г.<ref> Dunn, J. C. (1973-01-01). "A Fuzzy Relative of the ISODATA Process and Its Use in Detecting Compact Well-Separated Clusters". Journal of Cybernetics. 3 (3): 32–57. doi:10.1080/01969727308546046. ISSN 0022-0280.</ref>, усовершенствован J.C. Bezdek в 1981 г.<ref> Bezdek, James C. (1981). Pattern Recognition with Fuzzy Objective Function Algorithms. ISBN 0-306-40671-3.</ref>.

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

В общем виде алгоритм можно записать следующим образом:

# Инициализировать матрицу принадлежности;
# Вычислить центры кластеров;
# Вычислить значение решающей функции. Если значение ниже некоторого порогового или его улучшение по сравнению с предыдущей итерацией меньше определенной величины, то остановить вычисления;
# Иначе вычислить новые значения матрицы принадлежности;
# Перейти к шагу 2

== Математическое описание алгоритма ==
Рассмотрим матрицу <math> M = m_{ik} \in[0,1],\; i = 1, ..., c, \; k = 1, ..., K </math>. <math>m_{i,k}</math> - вероятность принадлежности объекта <math>k</math> к кластеру <math>i</math>; <math>c</math> - количество кластеров, <math>K</math> - количество векторов. При этом элементы матрицы удовлетворяют следующим условиям:

* сумма элементов в каждом столбце равна <math>1</math>;

* сумма всех элементов матрицы равно <math>K</math>;

Назовем <math> M </math> матрицей принадлежности.

Пусть <math>c_{i} (i = 1,2,...c)</math> - центры кластеров. Тогда рассмотрим функцию

<math>
\begin{align}
J(M, c_{1}, c_{2},...c_{c}) = \sum_{i = 1}^{c}{J_{i}} = \sum_{i = 1}^{c}\sum_{k = 1}^{K}{m_{ik}^q}d_{ik}^2 ~(1)
\end{align}
</math>

где <math> d_{ik} = \left\Vert{u_{k}-c_{i}}\right\| </math> - Евклидово расстояние между центром кластера и объектом, <math> 1 \le q \le \infty </math> - экспоненциальный весовой коэффициент, характеризующий нечеткость. Будем минимизировать значение функции <math> J </math>. Для этого вычислим центры кластеров по формуле <math> ~(2) </math>.

<math>c_{i} = {{\sum_{k = 1}^{K}{m_{ik}^q} * u_{k}} \over {\sum_{k = 1}^{K}{m_{ik}^q}}}~(2)</math>

где <math>m_{ik}</math> — коэффициент принадлежности <math>u_{k}</math> вектора к кластеру <math>c_{i}</math>

и новые значения матрицы <math> M </math> по формуле <math> ~(3) </math>

<math>m_{ik} = {1 \over \sum_{j = 1}^{c}{({{d_{ik}} \over {d_{jk}}})}^{2 \over q-1}} ~(3)</math>

<math> ~(2) </math> и <math> ~(3) </math>являются необходимым условиями достижения минимума функцией <math> J </math>. Таким образом эти два условия дают нам итерационный процесс.

Полностью алгоритм можно записать следующим образом:

# Инициализировать матрицу принадлежности <math> M </math> случайными значениями от 0 до 1;
# Вычислить центры кластеров <math>c_{i} (i = 1,2,...c)</math> используя формулу <math>~(2)</math>;
# Вычислить значение решающей функции по формуле <math>~(1)</math>. Если значение <math> J < \varepsilon,~\varepsilon > 0</math> или <math> |J_{i} - J_{i-1}| < \delta,~\delta > 0 </math>, то остановить вычисления;
# Иначе вычислить новые значения матрицы М по формуле <math>~(3)</math>;
# Перейти к шагу 2

== Вычислительное ядро алгоритма ==
Вычислительным ядром алгоритма являются формулы: <math> (1) </math>, <math> (2) </math>, <math> (3) </math>. В них производится вычисление новых центров кластеров, значения решающей функции и пересчет элементов матрицы принадлежности.

== Макроструктура алгоритма ==
Макроструктура алгоритма состоит из следующих шагов:

1) Инициализация матрицы <math> M </math> случайными значениями от 0 до 1;

2) Вычисление центров кластеров;

3) Вычисление значения решающей функции(если оно удовлетворяет условиям останова - завершение вычислений);

4) Вычисление новых элементов матрицы принадлежности;

5) Переход к шагу 2;

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

Пример реализации алгоритма на языке С++
<source lang="C++">

float ** m;
int *c;
int number_clusters, number_items;
m = gen_random_clusters();//заполним матрицу m случайными значениями от 0 до 1

while (true)
{
//вычисление центров кластеров
for (int i=0; i<number_clusters; i++)
{
numerator==denumerator=0;
for (int k=0; k<number_items; k++)
{
numerator+=pow(m[i, k], q)*u[k];//u[k]-вектор
denumerator+=pow(m[i, k], q);
}
c[i]= numerator / denumerator;//центры кластеров
}

j=0;//вычисление решающей функции
for (int i=0; i<number_clusters; i++)
for (int k=0; k<number_items; k++)
j+=pow(m[i, k], q)*pow(dist(c[i], x[k],2);//dist-вычисляет расстояние между заданными векторами

if ((abs(j-last_j)<delta) || (j<eps)) break;//проверка на необходимость завернешения алгоритма
last_j=j;
//обновление матрицы m
for (int i=0; i<number_clusters; i++)
for (int k=0; k<number_items; k++)
{
m[i,k]=0
for(int j=0; j<number_clusters; j++)
m[i,k]+=pow(dist(c[i], x[k])/dist(c[j], x[k]),2/(q-1));
m[i,k]=1/m[i,k];
}

}
</source>

== Последовательная сложность алгоритма ==
Каждая итерация включает в себя
* Вычисление центров кластеров <math>O(C*K)</math>
* Вычисление решающей функции <math>O(C*K)</math>
* Обновлене матрицы <math>M</math> <math>O(C*C*K)</math>
Общая сложность каждой итерации <math>O(C*C*K)</math>.

Сложность всего алгоритма будет зависеть от числа итераций, которое зависит от
* Выбора начального приближения
* Выбора условий останова

Окончательно, сложность алгоритма будет равна произведению количества итераций на их сложность

== Информационный граф ==
'''Первый ярус''' состоит из <math>C</math> параллельных операций, каждая их которых в свою очередь состоит из <math>K</math> параллельных операций, и одной, которая выполняется с использованием результата предыдущих.
Результатом работы этого яруса является значение <math>C</math> , которое будет использоваться на следующем ярусе.

'''Второй ярус''' содержит в себе <math>C*K</math> параллельных операций.
Результатом его работы является значение решающей функции <math>J</math>, значение которой влияет на необходимость завершения алгоритма.

'''Третий ярус''' включает <math>C*K</math> параллельных операций, каждая из которых состоит из <math>C</math> параллельных операций, и одной, которая выполняется с использованием результата предыдущих.

[[Файл:Снимок экрана 2016-10-15 в 23.10.05.png|582 px|thumb|center|Информационный граф]]

== Ресурс параллелизма алгоритма ==
== Входные и выходные данные алгоритма ==
Входные данные:
* <math>u_{k} k = 1, ..., K</math> - набор входных векторов;
* <math>C</math> - количество кластеров;
* <math>q</math> - экспоненциальный весовой коэффициент, характеризующий нечеткость;
* <math>\varepsilon > 0, ~\delta > 0</math> - коэффициенты, описывающие точность алгоритма.

Выходные данные:
* <math> M </math> - матрица принадлежности.

== Свойства алгоритма ==
*Соотношение последовательной и параллельной сложности алгоритма: <math>C*C*K \over (?)</math>. Соответственно при распараллеливании наибольший прирост в производительности мы получим при разбиении большого набора данных на большее число кластеров;
*Вычислительная мощность: <math>{{C^2*K} \over {C*K}} = C</math>. Получается, что на чем большее количество кластеров мы разбиваем набор данных, тем менее затратным становится перемещение данных;
*Алгоритм не является устойчивым, как и другие подобные алгоритмы этого класса(например k-means). Очень многое зависит как от входных данных, так и от изначальных параметров приближения(заполнения матрицы принадлежности => исходных центров кластеров);
*Не является детерминированным. Так же очень многое зависит как от входных данных, так и от изначальных параметров приближения(заполнения матрицы принадлежности => исходных центров кластеров);
*Алгоритм не сбалансирован - доминирует операция умножения. Параллельные ветви алгоритма сбалансированы;
*Степень исхода вершины информационного графа - 2.

= Программная реализация алгоритма =
== Особенности реализации последовательного алгоритма ==
== Локальность данных и вычислений ==
== Возможные способы и особенности параллельной реализации алгоритма ==
== Масштабируемость алгоритма и его реализации ==
== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Можно найти следующие реализации алгоритма
* Для MATLAB http://www.mathworks.com/help/fuzzy/fcm.html
* В PostgreSQL http://num-meth.srcc.msu.ru/zhurnal/tom_2012/v13r207.html
Так же готовые реализации алгоритма и его описание можно найти на сайтах
* https://habrahabr.ru/post/208496/
* http://pythonhosted.org/scikit-fuzzy/auto_examples/plot_cmeans.html
* http://www.codeproject.com/Articles/91675/Computer-Vision-Applications-with-C-Fuzzy-C-means
* https://github.com/gyaikhom/fcm

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

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

2016-10-15T20:42:24Z

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

{{algorithm
| name = Нечеткий алгоритм C средних
| serial_complexity =
| input_data =
| output_data =
| pf_height =
| pf_width =
}}

Авторы : [[Участник:Protsenko|Мария Проценко]] (1.5-1.8, 1.10, 2.7), [[Участник:ADovganich|Андрей Довганич]] (1.1-1.4, 1.9)

= Свойства и структура алгоритмов =
== Общее описание алгоритма ==
Нечеткий алгоритм C-средних (fuzzy C-means) позволяет разбить имеющееся множество векторов (точек) мощностью p на заданное число нечетких множеств. Предназначен для кластеризации больших наборов данных. Основным достоинством алгоритма является нечеткость при определении объекта в кластер. Благодаря этому становится возможным определить объекты, которые находятся на границе, в кластеры. Из основного достоинства следует и главный недостаток - неопределенность с объектами, удаленными от центров всех кластеров. В остальном ему присущи стандартные проблемы подобного класса алгоритмов: вычислительная сложность, необходимость задания количества кластеров<ref>Нейский И.М. Классификация и сравнение методов кластеризации</ref>.

Алгоритм был разработан J.C. Dunn в 1973 г.<ref> Dunn, J. C. (1973-01-01). "A Fuzzy Relative of the ISODATA Process and Its Use in Detecting Compact Well-Separated Clusters". Journal of Cybernetics. 3 (3): 32–57. doi:10.1080/01969727308546046. ISSN 0022-0280.</ref>, усовершенствован J.C. Bezdek в 1981 г.<ref> Bezdek, James C. (1981). Pattern Recognition with Fuzzy Objective Function Algorithms. ISBN 0-306-40671-3.</ref>.

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

В общем виде алгоритм можно записать следующим образом:

# Инициализировать матрицу принадлежности;
# Вычислить центры кластеров;
# Вычислить значение решающей функции. Если значение ниже некоторого порогового или его улучшение по сравнению с предыдущей итерацией меньше определенной величины, то остановить вычисления;
# Иначе вычислить новые значения матрицы принадлежности;
# Перейти к шагу 2

== Математическое описание алгоритма ==
Рассмотрим матрицу <math> M = m_{ik} \in[0,1],\; i = 1, ..., c, \; k = 1, ..., K </math>. <math>m_{i,k}</math> - вероятность принадлежности объекта <math>k</math> к кластеру <math>i</math>; <math>c</math> - количество кластеров, <math>K</math> - количество векторов. При этом элементы матрицы удовлетворяют следующим условиям:

- сумма элементов в каждом столбце равна <math>1</math>;

- сумма всех элементов матрицы равно <math>K</math>;

Назовем <math> M </math> матрицей принадлежности.

Пусть <math>c_{i} (i = 1,2,...c)</math> - центры кластеров. Тогда рассмотрим функцию

<math>
\begin{align}
J(M, c_{1}, c_{2},...c_{c}) = \sum_{i = 1}^{c}{J_{i}} = \sum_{i = 1}^{c}\sum_{k = 1}^{K}{m_{ik}^q}d_{ik}^2 ~(1)
\end{align}
</math>

где <math> d_{ik} = \left\Vert{u_{k}-c_{i}}\right\| </math> - Евклидово расстояние между центром кластера и объектом, <math> 1 \le q \le \infty </math> - экспоненциальный весовой коэффициент, характеризующий нечеткость. Будем минимизировать значение функции <math> J </math>. Для этого вычислим центры кластеров по формуле <math> ~(2) </math>.

<math>c_{i} = {{\sum_{k = 1}^{K}{m_{ik}^q} * u_{k}} \over {\sum_{k = 1}^{K}{m_{ik}^q}}}~(2)</math>

где <math>m_{ik}</math> — коэффициент принадлежности <math>u_{k}</math> вектора к кластеру <math>c_{i}</math>

и новые значения матрицы <math> M </math> по формуле <math> ~(3) </math>

<math>m_{ik} = {1 \over \sum_{j = 1}^{c}{({{d_{ik}} \over {d_{jk}}})}^{2 \over q-1}} ~(3)</math>

<math> ~(2) </math> и <math> ~(3) </math>являются необходимым условиями достижения минимума функцией <math> J </math>. Таким образом эти два условия дают нам итерационный процесс.

Полностью алгоритм можно записать следующим образом:

1) Инициализировать матрицу принадлежности <math> M </math> случайными значениями от 0 до 1;

2) Вычислить центры кластеров <math>c_{i} (i = 1,2,...c)</math> используя формулу <math>~(2)</math>;

3) Вычислить значение решающей функции по формуле <math>~(1)</math>. Если значение <math> J < \varepsilon,~\varepsilon > 0</math> или <math> |J_{i} - J_{i-1}| < \delta,~\delta > 0 </math>, то остановить вычисления;

4) Иначе вычислить новые значения матрицы М по формуле <math>~(3)</math>;

5) Перейти к шагу 2

== Вычислительное ядро алгоритма ==
Вычислительным ядром алгоритма являются формулы: <math> (1) </math>, <math> (2) </math>, <math> (3) </math>. В них производится вычисление новых центров кластеров, значения решающей функции и пересчет элементов матрицы принадлежности.

== Макроструктура алгоритма ==
Макроструктура алгоритма состоит из следующих шагов:

1) Инициализация матрицы <math> M </math> случайными значениями от 0 до 1;

2) Вычисление центров кластеров;

3) Вычисление значения решающей функции(если оно удовлетворяет условиям останова - завершение вычислений);

4) Вычисление новых элементов матрицы принадлежности;

5) Переход к шагу 2;

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

Пример реализации алгоритма на языке С++
<source lang="C++">

float ** m;
int *c;
int number_clusters, number_items;
m = gen_random_clusters();//заполним матрицу m случайными значениями от 0 до 1

while (true)
{
//вычисление центров кластеров
for (int i=0; i<number_clusters; i++)
{
numerator==denumerator=0;
for (int k=0; k<number_items; k++)
{
numerator+=pow(m[i, k], q)*u[k];//u[k]-вектор
denumerator+=pow(m[i, k], q);
}
c[i]= numerator / denumerator;//центры кластеров
}

j=0;//вычисление решающей функции
for (int i=0; i<number_clusters; i++)
for (int k=0; k<number_items; k++)
j+=pow(m[i, k], q)*pow(dist(c[i], x[k],2);//dist-вычисляет расстояние между заданными векторами

if ((abs(j-last_j)<delta) || (j<eps)) break;//проверка на необходимость завернешения алгоритма
last_j=j;
//обновление матрицы m
for (int i=0; i<number_clusters; i++)
for (int k=0; k<number_items; k++)
{
m[i,k]=0
for(int j=0; j<number_clusters; j++)
m[i,k]+=pow(dist(c[i], x[k])/dist(c[j], x[k]),2/(q-1));
m[i,k]=1/m[i,k];
}

}
</source>

== Последовательная сложность алгоритма ==
Каждая итерация включает в себя
* Вычисление центров кластеров <math>O(C*K)</math>
* Вычисление решающей функции <math>O(C*K)</math>
* Обновлене матрицы <math>M</math> <math>O(C*C*K)</math>
Общая сложность каждой итерации <math>O(C*C*K)</math>.

Сложность всего алгоритма будет зависеть от числа итераций, которое зависит от
* Выбора начального приближения
* Выбора условий останова

Окончательно, сложность алгоритма будет равна произведению количества итераций на их сложность

== Информационный граф ==
'''Первый ярус''' состоит из <math>C</math> параллельных операций, каждая их которых в свою очередь состоит из <math>K</math> параллельных операций, и одной, которая выполняется с использованием результата предыдущих.
Результатом работы этого яруса является значение <math>C</math> , которое будет использоваться на следующем ярусе.

'''Второй ярус''' содержит в себе <math>C*K</math> параллельных операций.
Результатом его работы является значение решающей функции <math>J</math>, значение которой влияет на необходимость завершения алгоритма.

'''Третий ярус''' включает <math>C*K</math> параллельных операций, каждая из которых состоит из <math>C</math> параллельных операций, и одной, которая выполняется с использованием результата предыдущих.

[[Файл:Снимок экрана 2016-10-15 в 23.10.05.png|582 px|thumb|center|Информационный граф]]

== Ресурс параллелизма алгоритма ==
== Входные и выходные данные алгоритма ==
Входные данные:
* <math>u_{k} k = 1, ..., K</math> - набор входных векторов;
* <math>C</math> - количество кластеров;
* <math>q</math> - экспоненциальный весовой коэффициент, характеризующий нечеткость;
* <math>\varepsilon > 0, ~\delta > 0</math> - коэффициенты, описывающие точность алгоритма.

Выходные данные:
* <math> M </math> - матрица принадлежности.

== Свойства алгоритма ==
*Соотношение последовательной и параллельной сложности алгоритма: <math>C*C*K \over (?)</math>. Соответственно при распараллеливании наибольший прирост в производительности мы получим при разбиении большого набора данных на большее число кластеров;
*Вычислительная мощность: <math>{{C^2*K} \over {C*K}} = C</math>. Получается, что на чем большее количество кластеров мы разбиваем набор данных, тем менее затратным становится перемещение данных;
*Алгоритм не является устойчивым, как и другие подобные алгоритмы этого класса(например k-means). Очень многое зависит как от входных данных, так и от изначальных параметров приближения(заполнения матрицы принадлежности => исходных центров кластеров);
*Не является детерминированным. Так же очень многое зависит как от входных данных, так и от изначальных параметров приближения(заполнения матрицы принадлежности => исходных центров кластеров);
*Алгоритм не сбалансирован - доминирует операция умножения. Параллельные ветви алгоритма сбалансированы;
*Степень исхода вершины информационного графа - 2.

= Программная реализация алгоритма =
== Особенности реализации последовательного алгоритма ==
== Локальность данных и вычислений ==
== Возможные способы и особенности параллельной реализации алгоритма ==
== Масштабируемость алгоритма и его реализации ==
== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Можно найти следующие реализации алгоритма
* Для MATLAB http://www.mathworks.com/help/fuzzy/fcm.html
* В PostgreSQL http://num-meth.srcc.msu.ru/zhurnal/tom_2012/v13r207.html
Так же готовые реализации алгоритма и его описание можно найти на сайтах
* https://habrahabr.ru/post/208496/
* http://pythonhosted.org/scikit-fuzzy/auto_examples/plot_cmeans.html
* http://www.codeproject.com/Articles/91675/Computer-Vision-Applications-with-C-Fuzzy-C-means
* https://github.com/gyaikhom/fcm

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

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

2016-10-15T20:41:04Z

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

{{algorithm
| name = Нечеткий алгоритм C средних
| serial_complexity =
| input_data =
| output_data =
| pf_height =
| pf_width =
}}

Авторы : [[Участник:Protsenko|Мария Проценко]] (1.5-1.8, 1.10, 2.7), [[Участник:ADovganich|Андрей Довганич]] (1.1-1.4, 1.9)

= Свойства и структура алгоритмов =
== Общее описание алгоритма ==
Нечеткий алгоритм C-средних (fuzzy C-means) позволяет разбить имеющееся множество векторов (точек) мощностью p на заданное число нечетких множеств. Предназначен для кластеризации больших наборов данных. Основным достоинством алгоритма является нечеткость при определении объекта в кластер. Благодаря этому становится возможным определить объекты, которые находятся на границе, в кластеры. Из основного достоинства следует и главный недостаток - неопределенность с объектами, удаленными от центров всех кластеров. В остальном ему присущи стандартные проблемы подобного класса алгоритмов: вычислительная сложность, необходимость задания количества кластеров<ref>Нейский И.М. Классификация и сравнение методов кластеризации</ref>.

Алгоритм был разработан J.C. Dunn в 1973 г.<ref> Dunn, J. C. (1973-01-01). "A Fuzzy Relative of the ISODATA Process and Its Use in Detecting Compact Well-Separated Clusters". Journal of Cybernetics. 3 (3): 32–57. doi:10.1080/01969727308546046. ISSN 0022-0280.</ref>, усовершенствован J.C. Bezdek в 1981 г.<ref> Bezdek, James C. (1981). Pattern Recognition with Fuzzy Objective Function Algorithms. ISBN 0-306-40671-3.</ref>.

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

В общем виде алгоритм можно записать следующим образом:

# Инициализировать матрицу принадлежности;

# Вычислить центры кластеров;

# Вычислить значение решающей функции. Если значение ниже некоторого порогового или его улучшение по сравнению с предыдущей итерацией меньше определенной величины, то остановить вычисления;

# Иначе вычислить новые значения матрицы принадлежности;

# Перейти к шагу 2

== Математическое описание алгоритма ==
Рассмотрим матрицу <math> M = m_{ik} \in[0,1],\; i = 1, ..., c, \; k = 1, ..., K </math>. <math>m_{i,k}</math> - вероятность принадлежности объекта <math>k</math> к кластеру <math>i</math>; <math>c</math> - количество кластеров, <math>K</math> - количество векторов. При этом элементы матрицы удовлетворяют следующим условиям:

- сумма элементов в каждом столбце равна <math>1</math>;

- сумма всех элементов матрицы равно <math>K</math>;

Назовем <math> M </math> матрицей принадлежности.

Пусть <math>c_{i} (i = 1,2,...c)</math> - центры кластеров. Тогда рассмотрим функцию

<math>
\begin{align}
J(M, c_{1}, c_{2},...c_{c}) = \sum_{i = 1}^{c}{J_{i}} = \sum_{i = 1}^{c}\sum_{k = 1}^{K}{m_{ik}^q}d_{ik}^2 ~(1)
\end{align}
</math>

где <math> d_{ik} = \left\Vert{u_{k}-c_{i}}\right\| </math> - Евклидово расстояние между центром кластера и объектом, <math> 1 \le q \le \infty </math> - экспоненциальный весовой коэффициент, характеризующий нечеткость. Будем минимизировать значение функции <math> J </math>. Для этого вычислим центры кластеров по формуле <math> ~(2) </math>.

<math>c_{i} = {{\sum_{k = 1}^{K}{m_{ik}^q} * u_{k}} \over {\sum_{k = 1}^{K}{m_{ik}^q}}}~(2)</math>

где <math>m_{ik}</math> — коэффициент принадлежности <math>u_{k}</math> вектора к кластеру <math>c_{i}</math>

и новые значения матрицы <math> M </math> по формуле <math> ~(3) </math>

<math>m_{ik} = {1 \over \sum_{j = 1}^{c}{({{d_{ik}} \over {d_{jk}}})}^{2 \over q-1}} ~(3)</math>

<math> ~(2) </math> и <math> ~(3) </math>являются необходимым условиями достижения минимума функцией <math> J </math>. Таким образом эти два условия дают нам итерационный процесс.

Полностью алгоритм можно записать следующим образом:

1) Инициализировать матрицу принадлежности <math> M </math> случайными значениями от 0 до 1;

2) Вычислить центры кластеров <math>c_{i} (i = 1,2,...c)</math> используя формулу <math>~(2)</math>;

3) Вычислить значение решающей функции по формуле <math>~(1)</math>. Если значение <math> J < \varepsilon,~\varepsilon > 0</math> или <math> |J_{i} - J_{i-1}| < \delta,~\delta > 0 </math>, то остановить вычисления;

4) Иначе вычислить новые значения матрицы М по формуле <math>~(3)</math>;

5) Перейти к шагу 2

== Вычислительное ядро алгоритма ==
Вычислительным ядром алгоритма являются формулы: <math> (1) </math>, <math> (2) </math>, <math> (3) </math>. В них производится вычисление новых центров кластеров, значения решающей функции и пересчет элементов матрицы принадлежности.

== Макроструктура алгоритма ==
Макроструктура алгоритма состоит из следующих шагов:

1) Инициализация матрицы <math> M </math> случайными значениями от 0 до 1;

2) Вычисление центров кластеров;

3) Вычисление значения решающей функции(если оно удовлетворяет условиям останова - завершение вычислений);

4) Вычисление новых элементов матрицы принадлежности;

5) Переход к шагу 2;

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

Пример реализации алгоритма на языке С++
<source lang="C++">

float ** m;
int *c;
int number_clusters, number_items;
m = gen_random_clusters();//заполним матрицу m случайными значениями от 0 до 1

while (true)
{
//вычисление центров кластеров
for (int i=0; i<number_clusters; i++)
{
numerator==denumerator=0;
for (int k=0; k<number_items; k++)
{
numerator+=pow(m[i, k], q)*u[k];//u[k]-вектор
denumerator+=pow(m[i, k], q);
}
c[i]= numerator / denumerator;//центры кластеров
}

j=0;//вычисление решающей функции
for (int i=0; i<number_clusters; i++)
for (int k=0; k<number_items; k++)
j+=pow(m[i, k], q)*pow(dist(c[i], x[k],2);//dist-вычисляет расстояние между заданными векторами

if ((abs(j-last_j)<delta) || (j<eps)) break;//проверка на необходимость завернешения алгоритма
last_j=j;
//обновление матрицы m
for (int i=0; i<number_clusters; i++)
for (int k=0; k<number_items; k++)
{
m[i,k]=0
for(int j=0; j<number_clusters; j++)
m[i,k]+=pow(dist(c[i], x[k])/dist(c[j], x[k]),2/(q-1));
m[i,k]=1/m[i,k];
}

}
</source>

== Последовательная сложность алгоритма ==
Каждая итерация включает в себя
* Вычисление центров кластеров <math>O(C*K)</math>
* Вычисление решающей функции <math>O(C*K)</math>
* Обновлене матрицы <math>M</math> <math>O(C*C*K)</math>
Общая сложность каждой итерации <math>O(C*C*K)</math>.

Сложность всего алгоритма будет зависеть от числа итераций, которое зависит от
* Выбора начального приближения
* Выбора условий останова

Окончательно, сложность алгоритма будет равна произведению количества итераций на их сложность

== Информационный граф ==
'''Первый ярус''' состоит из <math>C</math> параллельных операций, каждая их которых в свою очередь состоит из <math>K</math> параллельных операций, и одной, которая выполняется с использованием результата предыдущих.
Результатом работы этого яруса является значение <math>C</math> , которое будет использоваться на следующем ярусе.

'''Второй ярус''' содержит в себе <math>C*K</math> параллельных операций.
Результатом его работы является значение решающей функции <math>J</math>, значение которой влияет на необходимость завершения алгоритма.

'''Третий ярус''' включает <math>C*K</math> параллельных операций, каждая из которых состоит из <math>C</math> параллельных операций, и одной, которая выполняется с использованием результата предыдущих.

[[Файл:Снимок экрана 2016-10-15 в 23.10.05.png|582 px|thumb|center|Информационный граф]]

== Ресурс параллелизма алгоритма ==
== Входные и выходные данные алгоритма ==
Входные данные:
* <math>u_{k} k = 1, ..., K</math> - набор входных векторов;
* <math>C</math> - количество кластеров;
* <math>q</math> - экспоненциальный весовой коэффициент, характеризующий нечеткость;
* <math>\varepsilon > 0, ~\delta > 0</math> - коэффициенты, описывающие точность алгоритма.

Выходные данные:
* <math> M </math> - матрица принадлежности.

== Свойства алгоритма ==
*Соотношение последовательной и параллельной сложности алгоритма: <math>C*C*K \over (?)</math>. Соответственно при распараллеливании наибольший прирост в производительности мы получим при разбиении большого набора данных на большее число кластеров;
*Вычислительная мощность: <math>{{C^2*K} \over {C*K}} = C</math>. Получается, что на чем большее количество кластеров мы разбиваем набор данных, тем менее затратным становится перемещение данных;
*Алгоритм не является устойчивым, как и другие подобные алгоритмы этого класса(например k-means). Очень многое зависит как от входных данных, так и от изначальных параметров приближения(заполнения матрицы принадлежности => исходных центров кластеров);
*Не является детерминированным. Так же очень многое зависит как от входных данных, так и от изначальных параметров приближения(заполнения матрицы принадлежности => исходных центров кластеров);
*Алгоритм не сбалансирован - доминирует операция умножения. Параллельные ветви алгоритма сбалансированы;
*Степень исхода вершины информационного графа - 2.

= Программная реализация алгоритма =
== Особенности реализации последовательного алгоритма ==
== Локальность данных и вычислений ==
== Возможные способы и особенности параллельной реализации алгоритма ==
== Масштабируемость алгоритма и его реализации ==
== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Можно найти следующие реализации алгоритма
* Для MATLAB http://www.mathworks.com/help/fuzzy/fcm.html
* В PostgreSQL http://num-meth.srcc.msu.ru/zhurnal/tom_2012/v13r207.html
Так же готовые реализации алгоритма и его описание можно найти на сайтах
* https://habrahabr.ru/post/208496/
* http://pythonhosted.org/scikit-fuzzy/auto_examples/plot_cmeans.html
* http://www.codeproject.com/Articles/91675/Computer-Vision-Applications-with-C-Fuzzy-C-means
* https://github.com/gyaikhom/fcm

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

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

2016-10-15T20:33:57Z

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

{{algorithm
| name = Нечеткий алгоритм C средних
| serial_complexity =
| input_data =
| output_data =
| pf_height =
| pf_width =
}}

Авторы : [[Участник:Protsenko|Мария Проценко]] (1.5-1.8, 1.10, 2.7), [[Участник:ADovganich|Андрей Довганич]] (1.1-1.4, 1.9)

= Свойства и структура алгоритмов =
== Общее описание алгоритма ==
Нечеткий алгоритм C-средних (fuzzy C-means) позволяет разбить имеющееся множество векторов (точек) мощностью p на заданное число нечетких множеств. Предназначен для кластеризации больших наборов данных. Основным достоинством алгоритма является нечеткость при определении объекта в кластер. Благодаря этому становится возможным определить объекты, которые находятся на границе, в кластеры. Из основного достоинства следует и главный недостаток - неопределенность с объектами, удаленными от центров всех кластеров. В остальном ему присущи стандартные проблемы подобного класса алгоритмов: вычислительная сложность, необходимость задания количества кластеров<ref>Нейский И.М. Классификация и сравнение методов кластеризации</ref>.

Алгоритм был разработан J.C. Dunn в 1973 г.<ref> Dunn, J. C. (1973-01-01). "A Fuzzy Relative of the ISODATA Process and Its Use in Detecting Compact Well-Separated Clusters". Journal of Cybernetics. 3 (3): 32–57. doi:10.1080/01969727308546046. ISSN 0022-0280.</ref>, усовершенствован J.C. Bezdek в 1981 г.<ref> Bezdek, James C. (1981). Pattern Recognition with Fuzzy Objective Function Algorithms. ISBN 0-306-40671-3.</ref>.

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

В общем виде алгоритм можно записать следующим образом:

1) Инициализировать матрицу принадлежности;

2) Вычислить центры кластеров;

3) Вычислить значение решающей функции. Если значение ниже некоторого порогового или его улучшение по сравнению с предыдущей итерацией меньше определенной величины, то остановить вычисления;

4) Иначе вычислить новые значения матрицы принадлежности;

5) Перейти к шагу 2

== Математическое описание алгоритма ==
Рассмотрим матрицу <math> M = m_{ik} \in[0,1],\; i = 1, ..., c, \; k = 1, ..., K </math>. <math>m_{i,k}</math> - вероятность принадлежности объекта <math>k</math> к кластеру <math>i</math>; <math>c</math> - количество кластеров, <math>K</math> - количество векторов. При этом элементы матрицы удовлетворяют следующим условиям:

- сумма элементов в каждом столбце равна <math>1</math>;

- сумма всех элементов матрицы равно <math>K</math>;

Назовем <math> M </math> матрицей принадлежности.

Пусть <math>c_{i} (i = 1,2,...c)</math> - центры кластеров. Тогда рассмотрим функцию

<math>
\begin{align}
J(M, c_{1}, c_{2},...c_{c}) = \sum_{i = 1}^{c}{J_{i}} = \sum_{i = 1}^{c}\sum_{k = 1}^{K}{m_{ik}^q}d_{ik}^2 ~(1)
\end{align}
</math>

где <math> d_{ik} = \left\Vert{u_{k}-c_{i}}\right\| </math> - Евклидово расстояние между центром кластера и объектом, <math> 1 \le q \le \infty </math> - экспоненциальный весовой коэффициент, характеризующий нечеткость. Будем минимизировать значение функции <math> J </math>. Для этого вычислим центры кластеров по формуле <math> ~(2) </math>.

<math>c_{i} = {{\sum_{k = 1}^{K}{m_{ik}^q} * u_{k}} \over {\sum_{k = 1}^{K}{m_{ik}^q}}}~(2)</math>

где <math>m_{ik}</math> — коэффициент принадлежности <math>u_{k}</math> вектора к кластеру <math>c_{i}</math>

и новые значения матрицы <math> M </math> по формуле <math> ~(3) </math>

<math>m_{ik} = {1 \over \sum_{j = 1}^{c}{({{d_{ik}} \over {d_{jk}}})}^{2 \over q-1}} ~(3)</math>

<math> ~(2) </math> и <math> ~(3) </math>являются необходимым условиями достижения минимума функцией <math> J </math>. Таким образом эти два условия дают нам итерационный процесс.

Полностью алгоритм можно записать следующим образом:

1) Инициализировать матрицу принадлежности <math> M </math> случайными значениями от 0 до 1;

2) Вычислить центры кластеров <math>c_{i} (i = 1,2,...c)</math> используя формулу <math>~(2)</math>;

3) Вычислить значение решающей функции по формуле <math>~(1)</math>. Если значение <math> J < \varepsilon,~\varepsilon > 0</math> или <math> |J_{i} - J_{i-1}| < \delta,~\delta > 0 </math>, то остановить вычисления;

4) Иначе вычислить новые значения матрицы М по формуле <math>~(3)</math>;

5) Перейти к шагу 2

== Вычислительное ядро алгоритма ==
Вычислительным ядром алгоритма являются формулы: <math> (1) </math>, <math> (2) </math>, <math> (3) </math>. В них производится вычисление новых центров кластеров, значения решающей функции и пересчет элементов матрицы принадлежности.

== Макроструктура алгоритма ==
Макроструктура алгоритма состоит из следующих шагов:

1) Инициализация матрицы <math> M </math> случайными значениями от 0 до 1;

2) Вычисление центров кластеров;

3) Вычисление значения решающей функции(если оно удовлетворяет условиям останова - завершение вычислений);

4) Вычисление новых элементов матрицы принадлежности;

5) Переход к шагу 2;

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

Пример реализации алгоритма на языке С++
<source lang="C++">

float ** m;
int *c;
int number_clusters, number_items;
m = gen_random_clusters();//заполним матрицу m случайными значениями от 0 до 1

while (true)
{
//вычисление центров кластеров
for (int i=0; i<number_clusters; i++)
{
numerator==denumerator=0;
for (int k=0; k<number_items; k++)
{
numerator+=pow(m[i, k], q)*u[k];//u[k]-вектор
denumerator+=pow(m[i, k], q);
}
c[i]= numerator / denumerator;//центры кластеров
}

j=0;//вычисление решающей функции
for (int i=0; i<number_clusters; i++)
for (int k=0; k<number_items; k++)
j+=pow(m[i, k], q)*pow(dist(c[i], x[k],2);//dist-вычисляет расстояние между заданными векторами

if ((abs(j-last_j)<delta) || (j<eps)) break;//проверка на необходимость завернешения алгоритма
last_j=j;
//обновление матрицы m
for (int i=0; i<number_clusters; i++)
for (int k=0; k<number_items; k++)
{
m[i,k]=0
for(int j=0; j<number_clusters; j++)
m[i,k]+=pow(dist(c[i], x[k])/dist(c[j], x[k]),2/(q-1));
m[i,k]=1/m[i,k];
}

}
</source>

== Последовательная сложность алгоритма ==
Каждая итерация включает в себя
* Вычисление центров кластеров <math>O(C*K)</math>
* Вычисление решающей функции <math>O(C*K)</math>
* Обновлене матрицы <math>M</math> <math>O(C*C*K)</math>
Общая сложность каждой итерации <math>O(C*C*K)</math>.

Сложность всего алгоритма будет зависеть от числа итераций, которое зависит от
* Выбора начального приближения
* Выбора условий останова

Окончательно, сложность алгоритма будет равна произведению количества итераций на их сложность

== Информационный граф ==
'''Первый ярус''' состоит из <math>C</math> параллельных операций, каждая их которых в свою очередь состоит из <math>K</math> параллельных операций, и одной, которая выполняется с использованием результата предыдущих.
Результатом работы этого яруса является значение <math>C</math> , которое будет использоваться на следующем ярусе.

'''Второй ярус''' содержит в себе <math>C*K</math> параллельных операций.
Результатом его работы является значение решающей функции <math>J</math>, значение которой влияет на необходимость завершения алгоритма.

'''Третий ярус''' включает <math>C*K</math> параллельных операций, каждая из которых состоит из <math>C</math> параллельных операций, и одной, которая выполняется с использованием результата предыдущих.

[[Файл:Снимок экрана 2016-10-15 в 23.10.05.png|582 px|thumb|center|Информационный граф]]

== Ресурс параллелизма алгоритма ==
== Входные и выходные данные алгоритма ==
Входные данные:
* <math>u_{k} k = 1, ..., K</math> - набор входных векторов;
* <math>C</math> - количество кластеров;
* <math>q</math> - экспоненциальный весовой коэффициент, характеризующий нечеткость;
* <math>\varepsilon > 0, ~\delta > 0</math> - коэффициенты, описывающие точность алгоритма.

Выходные данные:
* <math> M </math> - матрица принадлежности.

== Свойства алгоритма ==
*Соотношение последовательной и параллельной сложности алгоритма: <math>C*C*K \over (?)</math>. Соответственно при распараллеливании наибольший прирост в производительности мы получим при разбиении большого набора данных на большее число кластеров;
*Вычислительная мощность: <math>{{C^2*K} \over {C*K}} = C</math>. Получается, что на чем большее количество кластеров мы разбиваем набор данных, тем менее затратным становится перемещение данных;
*Алгоритм не является устойчивым, как и другие подобные алгоритмы этого класса(например k-means). Очень многое зависит как от входных данных, так и от изначальных параметров приближения(заполнения матрицы принадлежности => исходных центров кластеров);
*Не является детерминированным. Так же очень многое зависит как от входных данных, так и от изначальных параметров приближения(заполнения матрицы принадлежности => исходных центров кластеров);
*Алгоритм не сбалансирован - доминирует операция умножения. Параллельные ветви алгоритма сбалансированы;
*Степень исхода вершины информационного графа - 2.

= Программная реализация алгоритма =
== Особенности реализации последовательного алгоритма ==
== Локальность данных и вычислений ==
== Возможные способы и особенности параллельной реализации алгоритма ==
== Масштабируемость алгоритма и его реализации ==
== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Можно найти следующие реализации алгоритма
* Для MATLAB http://www.mathworks.com/help/fuzzy/fcm.html
* В PostgreSQL http://num-meth.srcc.msu.ru/zhurnal/tom_2012/v13r207.html
Так же готовые реализации алгоритма и его описание можно найти на сайтах
* https://habrahabr.ru/post/208496/
* http://pythonhosted.org/scikit-fuzzy/auto_examples/plot_cmeans.html
* http://www.codeproject.com/Articles/91675/Computer-Vision-Applications-with-C-Fuzzy-C-means
* https://github.com/gyaikhom/fcm

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

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

2016-10-15T20:18:17Z

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

{{algorithm
| name = Нечеткий алгоритм C средних
| serial_complexity =
| input_data =
| output_data =
| pf_height =
| pf_width =
}}

Авторы : [[Участник:Protsenko|Мария Проценко]] (1.5-1.8, 1.10, 2.7), [[Участник:ADovganich|Андрей Довганич]] (1.1-1.4, 1.9)

= Свойства и структура алгоритмов =
== Общее описание алгоритма ==
Нечеткий алгоритм C-средних (fuzzy C-means) позволяет разбить имеющееся множество векторов (точек) мощностью p на заданное число нечетких множеств. Предназначен для кластеризации больших наборов данных. Основным достоинством алгоритма является нечеткость при определении объекта в кластер. Благодаря этому становится возможным определить объекты, которые находятся на границе, в кластеры. Из основного достоинства следует и главный недостаток - неопределенность с объектами, удаленными от центров всех кластеров. В остальном ему присущи стандартные проблемы подобного класса алгоритмов: вычислительная сложность, необходимость задания количества кластеров<ref>Нейский И.М. Классификация и сравнение методов кластеризации</ref>.

Алгоритм был разработан J.C. Dunn в 1973 г.<ref> Dunn, J. C. (1973-01-01). "A Fuzzy Relative of the ISODATA Process and Its Use in Detecting Compact Well-Separated Clusters". Journal of Cybernetics. 3 (3): 32–57. doi:10.1080/01969727308546046. ISSN 0022-0280.</ref>, усовершенствован J.C. Bezdek в 1981 г.<ref> Bezdek, James C. (1981). Pattern Recognition with Fuzzy Objective Function Algorithms. ISBN 0-306-40671-3.</ref>.

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

В общем виде алгоритм можно записать следующим образом:

1) Инициализировать матрицу принадлежности;

2) Вычислить центры кластеров;

3) Вычислить значение решающей функции. Если значение ниже некоторого порогового или его улучшение по сравнению с предыдущей итерацией меньше определенной величины, то остановить вычисления;

4) Иначе вычислить новые значения матрицы принадлежности;

5) Перейти к шагу 2

== Математическое описание алгоритма ==
Рассмотрим матрицу <math> M = m_{ik} \in[0,1],\; i = 1, ..., c, \; k = 1, ..., K </math>. <math>m_{i,k}</math> - вероятность принадлежности объекта <math>k</math> к кластеру <math>i</math>; <math>c</math> - количество кластеров, <math>K</math> - количество векторов. При этом элементы матрицы удовлетворяют следующим условиям:

- сумма элементов в каждом столбце равна <math>1</math>;

- сумма всех элементов матрицы равно <math>K</math>;

Назовем <math> M </math> матрицей принадлежности.

Пусть <math>c_{i} (i = 1,2,...c)</math> - центры кластеров. Тогда рассмотрим функцию

<math>
\begin{align}
J(M, c_{1}, c_{2},...c_{c}) = \sum_{i = 1}^{c}{J_{i}} = \sum_{i = 1}^{c}\sum_{k = 1}^{K}{m_{ik}^q}d_{ik}^2 ~(1)
\end{align}
</math>

где <math> d_{ik} = \left\Vert{u_{k}-c_{i}}\right\| </math> - Евклидово расстояние между центром кластера и объектом, <math> 1 \le q \le \infty </math> - экспоненциальный весовой коэффициент, характеризующий нечеткость. Будем минимизировать значение функции <math> J </math>. Для этого вычислим центры кластеров по формуле <math> ~(2) </math>.

<math>c_{i} = {{\sum_{k = 1}^{K}{m_{ik}^q} * u_{k}} \over {\sum_{k = 1}^{K}{m_{ik}^q}}}~(2)</math>

где <math>m_{ik}</math> — коэффициент принадлежности <math>u_{k}</math> вектора к кластеру <math>c_{i}</math>

и новые значения матрицы <math> M </math> по формуле <math> ~(3) </math>

<math>m_{ik} = {1 \over \sum_{j = 1}^{c}{({{d_{ik}} \over {d_{jk}}})}^{2 \over q-1}} ~(3)</math>

<math> ~(2) </math> и <math> ~(3) </math>являются необходимым условиями достижения минимума функцией <math> J </math>. Таким образом эти два условия дают нам итерационный процесс.

Полностью алгоритм можно записать следующим образом:

1) Инициализировать матрицу принадлежности <math> M </math> случайными значениями от 0 до 1;

2) Вычислить центры кластеров <math>c_{i} (i = 1,2,...c)</math> используя формулу <math>~(2)</math>;

3) Вычислить значение решающей функции по формуле <math>~(1)</math>. Если значение <math> J < \varepsilon,~\varepsilon > 0</math> или <math> |J_{i} - J_{i-1}| < \delta,~\delta > 0 </math>, то остановить вычисления;

4) Иначе вычислить новые значения матрицы М по формуле <math>~(3)</math>;

5) Перейти к шагу 2

== Вычислительное ядро алгоритма ==
Вычислительным ядром алгоритма являются формулы: <math> (1) </math>, <math> (2) </math>, <math> (3) </math>. В них производится вычисление новых центров кластеров, значения решающей функции и пересчет элементов матрицы принадлежности.

== Макроструктура алгоритма ==
Макроструктура алгоритма состоит из следующих шагов:

1) Инициализация матрицы <math> M </math> случайными значениями от 0 до 1;

2) Вычисление центров кластеров;

3) Вычисление значения решающей функции(если оно удовлетворяет условиям останова - завершение вычислений);

4) Вычисление новых элементов матрицы принадлежности;

5) Переход к шагу 2;

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

Пример реализации алгоритма на языке С++
<source lang="C++">

float ** m;
int *c;
int number_clusters, number_items;
m = gen_random_clusters();//заполним матрицу m случайными значениями от 0 до 1

while (true)
{
//вычисление центров кластеров
for (int i=0; i<number_clusters; i++)
{
numerator==denumerator=0;
for (int k=0; k<number_items; k++)
{
numerator+=pow(m[i, k], q)*u[k];//u[k]-вектор
denumerator+=pow(m[i, k], q);
}
c[i]= numerator / denumerator;//центры кластеров
}

j=0;//вычисление решающей функции
for (int i=0; i<number_clusters; i++)
for (int k=0; k<number_items; k++)
j+=pow(m[i, k], q)*pow(dist(c[i], x[k],2);//dist-вычисляет расстояние между заданными векторами

if ((abs(j-last_j)<delta) || (j<eps)) break;//проверка на необходимость завернешения алгоритма
last_j=j;
//обновление матрицы m
for (int i=0; i<number_clusters; i++)
for (int k=0; k<number_items; k++)
{
m[i,k]=0
for(int j=0; j<number_clusters; j++)
m[i,k]+=pow(dist(c[i], x[k])/dist(c[j], x[k]),2/(q-1));
m[i,k]=1/m[i,k];
}

}
</source>

== Последовательная сложность алгоритма ==
Каждая итерация включает в себя
* Вычисление центров кластеров <math>O(C*K)</math>
* Вычисление решающей функции <math>O(C*K)</math>
* Обновлене матрицы <math>M</math> <math>O(C*C*K)</math>
Общая сложность каждой итерации <math>O(C*C*K)</math>.

Сложность всего алгоритма будет зависеть от числа итераций, которое зависит от
* Выбора начального приближения
* Выбора условий останова

Окончательно, сложность алгоритма будет равна произведению количества итераций на их сложность

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

[[Файл:Снимок экрана 2016-10-15 в 23.10.05.png|582 px|thumb|center|Информационный граф]]

== Ресурс параллелизма алгоритма ==
== Входные и выходные данные алгоритма ==
Входные данные:
* <math>u_{k} k = 1, ..., K</math> - набор входных векторов;
* <math>C</math> - количество кластеров;
* <math>q</math> - экспоненциальный весовой коэффициент, характеризующий нечеткость;
* <math>\varepsilon > 0, ~\delta > 0</math> - коэффициенты, описывающие точность алгоритма.

Выходные данные:
* <math> M </math> - матрица принадлежности.

== Свойства алгоритма ==
*Соотношение последовательной и параллельной сложности алгоритма: <math>C*C*K \over (?)</math>. Соответственно при распараллеливании наибольший прирост в производительности мы получим при разбиении большого набора данных на большее число кластеров;
*Вычислительная мощность: <math>{{C^2*K} \over {C*K}} = C</math>. Получается, что на чем большее количество кластеров мы разбиваем набор данных, тем менее затратным становится перемещение данных;
*Алгоритм не является устойчивым, как и другие подобные алгоритмы этого класса(например k-means). Очень многое зависит как от входных данных, так и от изначальных параметров приближения(заполнения матрицы принадлежности => исходных центров кластеров);
*Не является детерминированным. Так же очень многое зависит как от входных данных, так и от изначальных параметров приближения(заполнения матрицы принадлежности => исходных центров кластеров);
*Алгоритм не сбалансирован - доминирует операция умножения. Параллельные ветви алгоритма сбалансированы;
*Степень исхода вершины информационного графа - 2.

= Программная реализация алгоритма =
== Особенности реализации последовательного алгоритма ==
== Локальность данных и вычислений ==
== Возможные способы и особенности параллельной реализации алгоритма ==
== Масштабируемость алгоритма и его реализации ==
== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Можно найти следующие реализации алгоритма
* Для MATLAB http://www.mathworks.com/help/fuzzy/fcm.html
* В PostgreSQL http://num-meth.srcc.msu.ru/zhurnal/tom_2012/v13r207.html
Так же готовые реализации алгоритма и его описание можно найти на сайтах
* https://habrahabr.ru/post/208496/
* http://pythonhosted.org/scikit-fuzzy/auto_examples/plot_cmeans.html
* http://www.codeproject.com/Articles/91675/Computer-Vision-Applications-with-C-Fuzzy-C-means
* https://github.com/gyaikhom/fcm

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

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

2016-10-15T20:17:18Z

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

{{algorithm
| name = Нечеткий алгоритм C средних
| serial_complexity =
| input_data =
| output_data =
| pf_height =
| pf_width =
}}

Авторы : [[Участник:Protsenko|Мария Проценко]] (1.5-1.8, 1.10, 2.7), [[Участник:ADovganich|Андрей Довганич]] (1.1-1.4, 1.9)

= Свойства и структура алгоритмов =
== Общее описание алгоритма ==
Нечеткий алгоритм C-средних (fuzzy C-means) позволяет разбить имеющееся множество векторов (точек) мощностью p на заданное число нечетких множеств. Предназначен для кластеризации больших наборов данных. Основным достоинством алгоритма является нечеткость при определении объекта в кластер. Благодаря этому становится возможным определить объекты, которые находятся на границе, в кластеры. Из основного достоинства следует и главный недостаток - неопределенность с объектами, удаленными от центров всех кластеров. В остальном ему присущи стандартные проблемы подобного класса алгоритмов: вычислительная сложность, необходимость задания количества кластеров<ref>Нейский И.М. Классификация и сравнение методов кластеризации</ref>.

Алгоритм был разработан J.C. Dunn в 1973 г.<ref> Dunn, J. C. (1973-01-01). "A Fuzzy Relative of the ISODATA Process and Its Use in Detecting Compact Well-Separated Clusters". Journal of Cybernetics. 3 (3): 32–57. doi:10.1080/01969727308546046. ISSN 0022-0280.</ref>, усовершенствован J.C. Bezdek в 1981 г.<ref> Bezdek, James C. (1981). Pattern Recognition with Fuzzy Objective Function Algorithms. ISBN 0-306-40671-3.</ref>.

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

В общем виде алгоритм можно записать следующим образом:

1) Инициализировать матрицу принадлежности;

2) Вычислить центры кластеров;

3) Вычислить значение решающей функции. Если значение ниже некоторого порогового или его улучшение по сравнению с предыдущей итерацией меньше определенной величины, то остановить вычисления;

4) Иначе вычислить новые значения матрицы принадлежности;

5) Перейти к шагу 2

== Математическое описание алгоритма ==
Рассмотрим матрицу <math> M = m_{ik} \in[0,1],\; i = 1, ..., c, \; k = 1, ..., K </math>. <math>m_{i,k}</math> - вероятность принадлежности объекта <math>k</math> к кластеру <math>i</math>; <math>c</math> - количество кластеров, <math>K</math> - количество векторов. При этом элементы матрицы удовлетворяют следующим условиям:

- сумма элементов в каждом столбце равна <math>1</math>;

- сумма всех элементов матрицы равно <math>K</math>;

Назовем <math> M </math> матрицей принадлежности.

Пусть <math>c_{i} (i = 1,2,...c)</math> - центры кластеров. Тогда рассмотрим функцию

<math>
\begin{align}
J(M, c_{1}, c_{2},...c_{c}) = \sum_{i = 1}^{c}{J_{i}} = \sum_{i = 1}^{c}\sum_{k = 1}^{K}{m_{ik}^q}d_{ik}^2 ~(1)
\end{align}
</math>

где <math> d_{ik} = \left\Vert{u_{k}-c_{i}}\right\| </math> - Евклидово расстояние между центром кластера и объектом, <math> 1 \le q \le \infty </math> - экспоненциальный весовой коэффициент, характеризующий нечеткость. Будем минимизировать значение функции <math> J </math>. Для этого вычислим центры кластеров по формуле <math> ~(2) </math>.

<math>c_{i} = {{\sum_{k = 1}^{K}{m_{ik}^q} * u_{k}} \over {\sum_{k = 1}^{K}{m_{ik}^q}}}~(2)</math>

где <math>m_{ik}</math> — коэффициент принадлежности <math>u_{k}</math> вектора к кластеру <math>c_{i}</math>

и новые значения матрицы <math> M </math> по формуле <math> ~(3) </math>

<math>m_{ik} = {1 \over \sum_{j = 1}^{c}{({{d_{ik}} \over {d_{jk}}})}^{2 \over q-1}} ~(3)</math>

<math> ~(2) </math> и <math> ~(3) </math>являются необходимым условиями достижения минимума функцией <math> J </math>. Таким образом эти два условия дают нам итерационный процесс.

Полностью алгоритм можно записать следующим образом:

1) Инициализировать матрицу принадлежности <math> M </math> случайными значениями от 0 до 1;

2) Вычислить центры кластеров <math>c_{i} (i = 1,2,...c)</math> используя формулу <math>~(2)</math>;

3) Вычислить значение решающей функции по формуле <math>~(1)</math>. Если значение <math> J < \varepsilon,~\varepsilon > 0</math> или <math> |J_{i} - J_{i-1}| < \delta,~\delta > 0 </math>, то остановить вычисления;

4) Иначе вычислить новые значения матрицы М по формуле <math>~(3)</math>;

5) Перейти к шагу 2

== Вычислительное ядро алгоритма ==
Вычислительным ядром алгоритма являются формулы: <math> (1) </math>, <math> (2) </math>, <math> (3) </math>. В них производится вычисление новых центров кластеров, значения решающей функции и пересчет элементов матрицы принадлежности.

== Макроструктура алгоритма ==
Макроструктура алгоритма состоит из следующих шагов:

1) Инициализация матрицы <math> M </math> случайными значениями от 0 до 1;

2) Вычисление центров кластеров;

3) Вычисление значения решающей функции(если оно удовлетворяет условиям останова - завершение вычислений);

4) Вычисление новых элементов матрицы принадлежности;

5) Переход к шагу 2;

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

Пример реализации алгоритма на языке С++
<source lang="C++">

float ** m;
int *c;
int number_clusters, number_items;
m = gen_random_clusters();//заполним матрицу m случайными значениями от 0 до 1

while (true)
{
//вычисление центров кластеров
for (int i=0; i<number_clusters; i++)
{
numerator==denumerator=0;
for (int k=0; k<number_items; k++)
{
numerator+=pow(m[i, k], q)*u[k];//u[k]-вектор
denumerator+=pow(m[i, k], q);
}
c[i]= numerator / denumerator;//центры кластеров
}

j=0;//вычисление решающей функции
for (int i=0; i<number_clusters; i++)
for (int k=0; k<number_items; k++)
j+=pow(m[i, k], q)*pow(dist(c[i], x[k],2);//dist-вычисляет расстояние между заданными векторами

if ((abs(j-last_j)<delta) || (j<eps)) break;//проверка на необходимость завернешения алгоритма
last_j=j;
//обновление матрицы m
for (int i=0; i<number_clusters; i++)
for (int k=0; k<number_items; k++)
{
m[i,k]=0
for(int j=0; j<number_clusters; j++)
m[i,k]+=pow(dist(c[i], x[k])/dist(c[j], x[k]),2/(q-1));
m[i,k]=1/m[i,k];
}

}
</source>

== Последовательная сложность алгоритма ==
Каждая итерация включает в себя
* Вычисление центров кластеров <math>O(C*K)</math>
* Вычисление решающей функции <math>O(C*K)</math>
* Обновлене матрицы <math>M</math> <math>O(C*C*K)</math>
Общая сложность каждой итерации <math>O(C*C*K)</math>.

Сложность всего алгоритма будет зависеть от числа итераций, которое зависит от
* Выбора начального приближения
* Выбора условий останова

Окончательно, сложность алгоритма будет равна произведению количества итераций на их сложность

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

[[Файл:Снимок экрана 2016-10-15 в 23.10.05.png|582 px|thumb|Информационный граф]]

== Ресурс параллелизма алгоритма ==
== Входные и выходные данные алгоритма ==
Входные данные:
* <math>u_{k} k = 1, ..., K</math> - набор входных векторов;
* <math>C</math> - количество кластеров;
* <math>q</math> - экспоненциальный весовой коэффициент, характеризующий нечеткость;
* <math>\varepsilon > 0, ~\delta > 0</math> - коэффициенты, описывающие точность алгоритма.

Выходные данные:
* <math> M </math> - матрица принадлежности.

== Свойства алгоритма ==
*Соотношение последовательной и параллельной сложности алгоритма: <math>C*C*K \over (?)</math>. Соответственно при распараллеливании наибольший прирост в производительности мы получим при разбиении большого набора данных на большее число кластеров;
*Вычислительная мощность: <math>{{C^2*K} \over {C*K}} = C</math>. Получается, что на чем большее количество кластеров мы разбиваем набор данных, тем менее затратным становится перемещение данных;
*Алгоритм не является устойчивым, как и другие подобные алгоритмы этого класса(например k-means). Очень многое зависит как от входных данных, так и от изначальных параметров приближения(заполнения матрицы принадлежности => исходных центров кластеров);
*Не является детерминированным. Так же очень многое зависит как от входных данных, так и от изначальных параметров приближения(заполнения матрицы принадлежности => исходных центров кластеров);
*Алгоритм не сбалансирован - доминирует операция умножения. Параллельные ветви алгоритма сбалансированы;
*Степень исхода вершины информационного графа - 2.

= Программная реализация алгоритма =
== Особенности реализации последовательного алгоритма ==
== Локальность данных и вычислений ==
== Возможные способы и особенности параллельной реализации алгоритма ==
== Масштабируемость алгоритма и его реализации ==
== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Можно найти следующие реализации алгоритма
* Для MATLAB http://www.mathworks.com/help/fuzzy/fcm.html
* В PostgreSQL http://num-meth.srcc.msu.ru/zhurnal/tom_2012/v13r207.html
Так же готовые реализации алгоритма и его описание можно найти на сайтах
* https://habrahabr.ru/post/208496/
* http://pythonhosted.org/scikit-fuzzy/auto_examples/plot_cmeans.html
* http://www.codeproject.com/Articles/91675/Computer-Vision-Applications-with-C-Fuzzy-C-means
* https://github.com/gyaikhom/fcm

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

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

2016-10-15T20:13:40Z

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

{{algorithm
| name = Нечеткий алгоритм C средних
| serial_complexity =
| input_data =
| output_data =
| pf_height =
| pf_width =
}}

Авторы : [[Участник:Protsenko|Мария Проценко]] (1.5-1.8, 1.10, 2.7), [[Участник:ADovganich|Андрей Довганич]] (1.1-1.4, 1.9)

= Свойства и структура алгоритмов =
== Общее описание алгоритма ==
Нечеткий алгоритм C-средних (fuzzy C-means) позволяет разбить имеющееся множество векторов (точек) мощностью p на заданное число нечетких множеств. Предназначен для кластеризации больших наборов данных. Основным достоинством алгоритма является нечеткость при определении объекта в кластер. Благодаря этому становится возможным определить объекты, которые находятся на границе, в кластеры. Из основного достоинства следует и главный недостаток - неопределенность с объектами, удаленными от центров всех кластеров. В остальном ему присущи стандартные проблемы подобного класса алгоритмов: вычислительная сложность, необходимость задания количества кластеров<ref>Нейский И.М. Классификация и сравнение методов кластеризации</ref>.

Алгоритм был разработан J.C. Dunn в 1973 г.<ref> Dunn, J. C. (1973-01-01). "A Fuzzy Relative of the ISODATA Process and Its Use in Detecting Compact Well-Separated Clusters". Journal of Cybernetics. 3 (3): 32–57. doi:10.1080/01969727308546046. ISSN 0022-0280.</ref>, усовершенствован J.C. Bezdek в 1981 г.<ref> Bezdek, James C. (1981). Pattern Recognition with Fuzzy Objective Function Algorithms. ISBN 0-306-40671-3.</ref>.

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

В общем виде алгоритм можно записать следующим образом:

1) Инициализировать матрицу принадлежности;

2) Вычислить центры кластеров;

3) Вычислить значение решающей функции. Если значение ниже некоторого порогового или его улучшение по сравнению с предыдущей итерацией меньше определенной величины, то остановить вычисления;

4) Иначе вычислить новые значения матрицы принадлежности;

5) Перейти к шагу 2

== Математическое описание алгоритма ==
Рассмотрим матрицу <math> M = m_{ik} \in[0,1],\; i = 1, ..., c, \; k = 1, ..., K </math>. <math>m_{i,k}</math> - вероятность принадлежности объекта <math>k</math> к кластеру <math>i</math>; <math>c</math> - количество кластеров, <math>K</math> - количество векторов. При этом элементы матрицы удовлетворяют следующим условиям:

- сумма элементов в каждом столбце равна <math>1</math>;

- сумма всех элементов матрицы равно <math>K</math>;

Назовем <math> M </math> матрицей принадлежности.

Пусть <math>c_{i} (i = 1,2,...c)</math> - центры кластеров. Тогда рассмотрим функцию

<math>
\begin{align}
J(M, c_{1}, c_{2},...c_{c}) = \sum_{i = 1}^{c}{J_{i}} = \sum_{i = 1}^{c}\sum_{k = 1}^{K}{m_{ik}^q}d_{ik}^2 ~(1)
\end{align}
</math>

где <math> d_{ik} = \left\Vert{u_{k}-c_{i}}\right\| </math> - Евклидово расстояние между центром кластера и объектом, <math> 1 \le q \le \infty </math> - экспоненциальный весовой коэффициент, характеризующий нечеткость. Будем минимизировать значение функции <math> J </math>. Для этого вычислим центры кластеров по формуле <math> ~(2) </math>.

<math>c_{i} = {{\sum_{k = 1}^{K}{m_{ik}^q} * u_{k}} \over {\sum_{k = 1}^{K}{m_{ik}^q}}}~(2)</math>

где <math>m_{ik}</math> — коэффициент принадлежности <math>u_{k}</math> вектора к кластеру <math>c_{i}</math>

и новые значения матрицы <math> M </math> по формуле <math> ~(3) </math>

<math>m_{ik} = {1 \over \sum_{j = 1}^{c}{({{d_{ik}} \over {d_{jk}}})}^{2 \over q-1}} ~(3)</math>

<math> ~(2) </math> и <math> ~(3) </math>являются необходимым условиями достижения минимума функцией <math> J </math>. Таким образом эти два условия дают нам итерационный процесс.

Полностью алгоритм можно записать следующим образом:

1) Инициализировать матрицу принадлежности <math> M </math> случайными значениями от 0 до 1;

2) Вычислить центры кластеров <math>c_{i} (i = 1,2,...c)</math> используя формулу <math>~(2)</math>;

3) Вычислить значение решающей функции по формуле <math>~(1)</math>. Если значение <math> J < \varepsilon,~\varepsilon > 0</math> или <math> |J_{i} - J_{i-1}| < \delta,~\delta > 0 </math>, то остановить вычисления;

4) Иначе вычислить новые значения матрицы М по формуле <math>~(3)</math>;

5) Перейти к шагу 2

== Вычислительное ядро алгоритма ==
Вычислительным ядром алгоритма являются формулы: <math> (1) </math>, <math> (2) </math>, <math> (3) </math>. В них производится вычисление новых центров кластеров, значения решающей функции и пересчет элементов матрицы принадлежности.

== Макроструктура алгоритма ==
Макроструктура алгоритма состоит из следующих шагов:

1) Инициализация матрицы <math> M </math> случайными значениями от 0 до 1;

2) Вычисление центров кластеров;

3) Вычисление значения решающей функции(если оно удовлетворяет условиям останова - завершение вычислений);

4) Вычисление новых элементов матрицы принадлежности;

5) Переход к шагу 2;

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

Пример реализации алгоритма на языке С++
<source lang="C++">

float ** m;
int *c;
int number_clusters, number_items;
m = gen_random_clusters();//заполним матрицу m случайными значениями от 0 до 1

while (true)
{
//вычисление центров кластеров
for (int i=0; i<number_clusters; i++)
{
numerator==denumerator=0;
for (int k=0; k<number_items; k++)
{
numerator+=pow(m[i, k], q)*u[k];//u[k]-вектор
denumerator+=pow(m[i, k], q);
}
c[i]= numerator / denumerator;//центры кластеров
}

j=0;//вычисление решающей функции
for (int i=0; i<number_clusters; i++)
for (int k=0; k<number_items; k++)
j+=pow(m[i, k], q)*pow(dist(c[i], x[k],2);//dist-вычисляет расстояние между заданными векторами

if ((abs(j-last_j)<delta) || (j<eps)) break;//проверка на необходимость завернешения алгоритма
last_j=j;
//обновление матрицы m
for (int i=0; i<number_clusters; i++)
for (int k=0; k<number_items; k++)
{
m[i,k]=0
for(int j=0; j<number_clusters; j++)
m[i,k]+=pow(dist(c[i], x[k])/dist(c[j], x[k]),2/(q-1));
m[i,k]=1/m[i,k];
}

}
</source>

== Последовательная сложность алгоритма ==
Каждая итерация включает в себя
* Вычисление центров кластеров <math>O(C*K)</math>
* Вычисление решающей функции <math>O(C*K)</math>
* Обновлене матрицы <math>M</math> <math>O(C*C*K)</math>
Общая сложность каждой итерации <math>O(C*C*K)</math>.

Сложность всего алгоритма будет зависеть от числа итераций, которое зависит от
* Выбора начального приближения
* Выбора условий останова

Окончательно, сложность алгоритма будет равна произведению количества итераций на их сложность

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

[[Файл:Снимок экрана 2016-10-15 в 23.10.05.png|582 px|thumb|left|Информационный граф]]

== Ресурс параллелизма алгоритма ==
== Входные и выходные данные алгоритма ==
Входные данные:
* <math>u_{k} k = 1, ..., K</math> - набор входных векторов;
* <math>C</math> - количество кластеров;
* <math>q</math> - экспоненциальный весовой коэффициент, характеризующий нечеткость;
* <math>\varepsilon > 0, ~\delta > 0</math> - коэффициенты, описывающие точность алгоритма.

Выходные данные:
* <math> M </math> - матрица принадлежности.

== Свойства алгоритма ==
*Соотношение последовательной и параллельной сложности алгоритма: <math>C*C*K \over (?)</math>. Соответственно при распараллеливании наибольший прирост в производительности мы получим при разбиении большого набора данных на большее число кластеров;
*Вычислительная мощность: <math>{{C^2*K} \over {C*K}} = C</math>. Получается, что на чем большее количество кластеров мы разбиваем набор данных, тем менее затратным становится перемещение данных;
*Алгоритм не является устойчивым, как и другие подобные алгоритмы этого класса(например k-means). Очень многое зависит как от входных данных, так и от изначальных параметров приближения(заполнения матрицы принадлежности => исходных центров кластеров);
*Не является детерминированным. Так же очень многое зависит как от входных данных, так и от изначальных параметров приближения(заполнения матрицы принадлежности => исходных центров кластеров);
*Алгоритм не сбалансирован - доминирует операция умножения. Параллельные ветви алгоритма сбалансированы;
*Степень исхода вершины информационного графа - 2.

= Программная реализация алгоритма =
== Особенности реализации последовательного алгоритма ==
== Локальность данных и вычислений ==
== Возможные способы и особенности параллельной реализации алгоритма ==
== Масштабируемость алгоритма и его реализации ==
== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Можно найти следующие реализации алгоритма
* Для MATLAB http://www.mathworks.com/help/fuzzy/fcm.html
* В PostgreSQL http://num-meth.srcc.msu.ru/zhurnal/tom_2012/v13r207.html
Так же готовые реализации алгоритма и его описание можно найти на сайтах
* https://habrahabr.ru/post/208496/
* http://pythonhosted.org/scikit-fuzzy/auto_examples/plot_cmeans.html
* http://www.codeproject.com/Articles/91675/Computer-Vision-Applications-with-C-Fuzzy-C-means
* https://github.com/gyaikhom/fcm

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