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

Участник:ЕкатеринаКозырева/Алгоритм динамической иерархической кластеризации CHAMELEON

2016-12-18T20:11:02Z

ЕкатеринаКозырева: /* Возможные способы и особенности параллельной реализации алгоритма */

{{Assignment|Kronberg}}
{{algorithm
| name = Алгоритм динамической иерархической кластеризации CHAMELEON
| serial_complexity = <math>O(nm + n log n + m^2 log m)</math>
| input_data = <math>\frac{n (n - 1)}{2}</math>
| output_data = <math>n</math>
| pf_height = <math>O(n+ n log(n) + m^2 log (m) + m log(m))</math>
| pf_width = <math>O(n)</math>
}}

Автор описания [[Участник:ЕкатеринаКозырева|Е.А.Козырева]]
= Свойства и структура алгоритмов =

== Общее описание алгоритма ==
Алгоритм CHAMELEON был предложен в 1999 году тремя учеными из университета Миннесоты – George Karypis, Eui-Hong (Sam) Han и Vipin Kumar<ref>George Karypis, Eui-Hong (Sam) Han и Vipin Kumar, «Chameleon: Hierarchical Clustering Using Dynamic Modeling», 1999.</ref>.

Предназначен для решения задач кластеризации. Кластеризация (или кластерный анализ) — это задача разбиения множества объектов на группы, называемые кластерами. Внутри каждой группы должны оказаться «похожие» объекты, а объекты разных группы должны быть как можно более отличны.

CHAMELEON - это агломеративный иерархический алгоритм кластеризации, ключевой особенностью которого является то, что он учитывает и взаимную связность, и сходство при определении наиболее похожей пары подкластеров, основываясь на динамической модели. Это означает, что в процессе кластеризации два кластера объединяются, только если их относительная взаимная связность и относительное взаимное сходство являются высокими по отношению к внутренней взаимосвязанности кластеров и близости элементов внутри кластеров. Кроме того, CHAMELEON использует подход для моделирования степени взаимосвязанности и близости между каждой парой кластеров, который учитывает внутренние характеристики самих кластеров. Таким образом, он может автоматически адаптироваться к внутренним характеристикам объединяемых кластеров.

CHAMELEON находит кластеры в наборе данных с помощью трехфазного алгоритма. На первой фазе происходит построение графа, путём добавления рёбер по принципу k ближайших соседей. На второй фазе CHAMELEON группирует полученные элементы в множество относительно небольших подграфов. Во время третьей фазы применяется агломеративный иерархический алгоритм кластеризации, с помощью которого находятся естесственные кластеры путем многократного объединения подграфов, полученных на прошлом этапе.

[[File:Chameleon.png|1000px|thumb|center|Рисунок 1. Общая структура алгоритма CHAMELEON]]

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

''Исходные данные'':

* Множество из n точек <math>V= {v_{ij}}</math> в метрическом пространстве, которое задано симметрической матрицей расстояний <math>A</math> размера <math>n\times n</math>.
* <math>k</math> - количество ближайших соседей для вершин, <math>k \in N, k \leq n</math>.
* <math>l</math> - наименьшее число вершин, которое может содержать наибольший подграф на 2-м этапе, <math>l \in N, l \leq n</math>.

''Обозначения'':

* <math>G = (V, E)</math> - граф, полученный путём соединения каждой точки с её <math>k</math> ближайшими соседями.

* <math>K= \{K_{i}\}</math> - разбиение множества <math>V</math> на набор попарно непересекающихся связных подмножеств, полученное в результате выполнения второй фазы алгоритма.

* <math>G_{2} = (K, E_{2})</math> - взвешенный граф, вершинами которого являются получившиеся подграфы, а ребрами - количество ребер исходного графа, соединяющих соответствующие подграфы.

* <math>C = \{C_{i}\}</math> - итоговое разбиение множества вершин графа <math>G_{2}</math> на набор кластеров.

''Вспомогательные понятия''

*<math>EC_{(C_{i},C_{j})}</math> - абсолютная взаимная связность пары кластеров <math>C_{i}, C{j}</math>. Определяется как сумма весов ребер, соединяющих вершины, принадлежащие <math>C{i}</math> c вершинами из <math>C{j}</math>. Внутренняя связность <math>EC_{(C_{i},C_{i})}</math> вычисляется как сумма ребер, входящих в разделитель, разбивающий <math>C{i}</math> на два равных подграфа.

*<math>RI_{(C_{i},C_{j})} = \frac{|EC_{(C_{i},C_{j})}|}{(|EC_{C_{i}}|+|EC_{C_{j}}|)/2}</math> - относительная взаимная связность пары кластеров <math>C_{i}, C{j}</math>

*<math>S_{EC_{(C_{i},C_{j})}}</math> - абсолютное взаимное сходство пары кластеров <math>C_{i}, C{j}</math>. Подсчитывается как среднее сходство между соединенными вершинами, принадлежащими <math>C{i}</math> и <math>C{j}</math> соответственно. Соединения обусловлены разбиением общего графа, полученного на первом этапе алгоритма.

*<math> RC_{(C_{i},C_{j})}= \frac{S_{EC_{(C_{i},C_{j})}}}{\frac{|C_{i}|}{|C_{i}+C_{j}|}*S_{EC_{(C_{i})}}+\frac{|C_{i}|}{|C_{i}+C_{j}|}*S_{EC_{(C_{j})}}}</math> - относительное взаимное сходство пары кластеров <math>C_{i}, C{j}</math>. Определяется как абсолютное сходство между этой парой кластеров, нормализованное с учетом их внутреннего сходства<ref>http://studopedia.ru/7_41934_algoritm-dinamicheskoy-ierarhicheskoy-klasterizatsii-CHAMELEON.html</ref>.

'''Первый этап'''

На первом этапе, согласно графо-ориентированному подходу, происходит построение графа <math>G = (V, E)</math> на матрице сходства объектов по принципу k ближайших соседей. Две вершины такого графа соединяет ребро, если объект, соответствующий любой из этих вершин попадает в число k наиболее близких объектов для объекта, соответствующего другой вершине из данной пары.
[[Файл:Снимок chameleon 2.png|2000px|thumb|Рисунок 2. Объекты в пространстве - слева, граф по принципу 1-го ближайшего соседа - по центру, граф по принципу 3-х ближайших соседей - справа ]]

'''Второй этап'''

Алгоритм разделяет полученный граф на множество сравнительно малых подграфов <math>K= \{K_{i}\}</math>. Разделение происходит последовательно. На каждом шаге выбирается подграф, содержащий наибольшее число вершин. Этот граф разделяется на два подграфа так, что разделитель ребер графа минимален и каждый из получаемых подграфов содержит не менее 25 % вершин исходного графа. Процесс разделения останавливается, когда наибольший подграф содержит меньше некоторого заданного числа вершин. Обычно величина этого параметра задается равной значению от 1 до 5 % от числа объектов. Полученное множество связных графов считается множеством начальных кластеров, на котором требуется провести последовательное иерархическое объединение.

'''Третий этап'''

Третий этап заключается в итеративном преобразовании множества подграфов <math>K= \{K_{i}\}</math> в множество кластеров <math>C = \{C_{i}\}</math>. Алгоритм осуществляет агломеративную иерархическую кластеризацию на основании показателей <math>EC_{(C_{i},C_{j})}</math>, <math>S_{EC_{(C_{i},C_{j})}}</math>, <math>RI_{(C_{i},C_{j})} </math>, <math> RC_{(C_{i},C_{j})}</math>. Существует две стратегии анализа показателей сходства. Первая подразумевает наличие некоторых пороговых значений <math>T_{RI}</math> и <math>T_{RC}</math>. В соответствии с этой стратегией, алгоритм для каждого кластера <math>C_{i}</math> проверяет, отвечают ли смежные (наиболее близкие) ему кластеры условиям:

*<math>RI_{(C_{i},C_{j})} \geqslant T_{RI}</math>

*<math>RC_{(C_{i},C_{j})} \geqslant T_{RC}</math>

Если более одного смежного кластера отвечает этим условиям, то алгоритм выбирает для объединения наиболее связный кластер (граф), то есть такой кластер <math>C_{j}</math>, с которым у кластера <math>C_{i}</math> получается наибольшая абсолютная взаимная связность. По завершению прохода по всем кластерам, созданные таким образом пары объединяются. Параметры <math>T_{RI}</math> и <math>T_{RC}</math> могут использоваться для изменения характеристик получаемых кластеров.

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

<math>RI_{(C_{i},C_{j})}*RC_{(C_{i},C_{j})}^\alpha</math>,

где <math>\alpha</math> выбирается пользователем. Если <math>\alpha > 1 </math>, то алгоритм придает большее значение относительному взаимному сходству, а если <math>\alpha < 1 </math>, то большее значение имеет относительная взаимная связность.

''Вычисляемые данные'':

<math>U = (u_1, u_2, ..., u_n)</math> - n-мерный вектор, где <math>u_i \in N_{[C]}</math> - порядковый номер кластера, к которому принадлежит вершина i исходного множества V.

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

Алгоритм имеет три вычислительных ядра, по одному на каждый этап.

На первом этапе вычислительным ядром является процесс нахождения <math>k</math> ближайших соседей для каждой вершины, который заключается в анализе матрицы расстояний.

На втором этапе вычислительным ядром является процесс поиска подходящего разбиения очередного подграфа на два графа с минимизацией разделителя ребер графа.

На третьем этапе вычислительным ядром является расчет величин <math>EC_{(C_{i},C_{j})}</math>, <math>S_{EC_{(C_{i},C_{j})}}</math>, <math>RI_{(C_{i},C_{j})} </math>, <math> RC_{(C_{i},C_{j})}</math> для каждой пары смежных кластеров.

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

Как уже рассказывалось ранее, алгоритм включает в себя три основных этапа, каждый из которых, по сути, является отдельным алгоритмом. Этапы выполняются последовательно относительно друг друга.

Макрооперация на первом этапе - процедура нахождения <math>k</math> ближайших соседей, на втором - процедура разбиения наибольшего подграфа на два графа, на третьем - процедура вычисления показателей сходства, на основе которых принимается решение о слиянии подграфов в кластер.

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

'''Первый этап'''
<source lang="cpp">
int n; //количество вершин
int k; //количество соседей
int A[n][n] //матрица расстояний
int D[k] //массив вершин-соседей
int E[n][n] //матрица ребер графа <math>G_{2} = (K, E_{2})</math>
for i=1 to n-1 do
{
for j=i+1 to n do
{
//заполняем массив вершин-соседей вставляя новые вершины, если они ближе, чем самая далекая из массива.
}
for j=0 to k do
{
//для каждой вершины соседа заполняем соответствующую ячейку из матрицы E[n][n] единицей
}

}
</source>

'''Второй этап'''

1. Все связные подграфы в отсортированном порядке помещаются в список;
2. Берем наибольший элемент списка, вычисляем количество его вершин. Если число вершин > l, то идем в пункт 3. Иначе в пункт 5;
3. Разбиваем подграф на два подграфа таким образом, чтобы разделитель ребер графа был минимален и каждый из получаемых подграфов содержал не менее 25 % вершин исходного графа;
4. Добавляем полученные элементы в список подграфов таким образом, чтобы список оставался отсортированным. Идем в пункт 2;
5. Нашли искомое множество подграфов math>K = \{K_{i}\}</math>;
6. Создаем и заполняем матрицу матрицу расстояний для графа <math>G_{2} = (K, E_{2})</math>. Получаем искомый набор рёбер <math>E_{2}</math>.

'''Третий этап'''

1. Заводим два массива: а) массив кластеров C, полученных на предыдущем этапе, б) массив объединений кластеров F, которые мы будем получать на этом этапе;
2. Берем следующий кластер <math>C_{i}</math> (на первом шаге - первый). Если все кластеры просмотрены, идем в пункт 6;
3. Берем следующий кластер <math>C_{j}, i<>j</math>. Если все кластеры просмотрены, то идем в пункт 2;
4. Проверяем смежность <math>C_{i}</math> и <math>C_{j}</math>. Если не смежны, то возвращаемся в пункт 3. Если смежны, идем в пункт 5;
5. Рассчитываем показатели <math>RI_{(C_{i},C_{j})}</math> и <math> RC_{(C_{i},C_{j})}</math>. Проверяем, удовлетворяют ли найденные значения условиям:
*<math>RI_{(C_{i},C_{j})} \geqslant T_{RI}</math>
*<math>RC_{(C_{i},C_{j})} \geqslant T_{RC}</math>
Если нет, то идем в пункт 3. Иначе если смежность пары кластеров выше, чем у предыдущих найденных, то <math>F_{i}=j</math>. Идем в пункт 3;
6. Если в списке F есть хотя бы одна пара кластеров для слияния, то выполняем слияние, обновляем массив кластеров и массив объединений кластеров. Идем в пункт 2.

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

1) Для построения графа на основе метода k ближайших соседей для n вершин требуется <math>O(n log(n))</math> операций <ref>J.H. Friedman, J.L. Bentley, and R.A. Finkel. An algorithm for ﬁnding best matches in logarithmic expected time. ACM Transactions on Mathematical Software, 3:209–226, 1977.</ref>; для наборов данных большой размерности эта величина составляет <math>O(n^2)</math> операций <ref>S. Berchtold, C. Bohm, D. Keim, and H.-P. Kriegel. Cost model for nearest neighbor search in high dimensional data space. In Proc. of Symposium on Principles of Database Systems, Tucson, Arizona, 1997.</ref>;

2) Для выделения множества сравнительно малых связных подграфов требуется <math>nm</math> операций, где <math>m</math> - количество подграфов, полученных на втором этапе алгоритма;

3) Формирование набора кластеров, на основе множества подграфов, полученных на предыдущем этапе, требует <math>m^2log(m)</math> операций.

Итого, для n вершин получаем последовательную сложность <math>O(n log(n)+nm+m^2log(m))</math>.

== Информационный граф ==
[[File:СК.png]]

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

Первый этап работы алгоритма можно распределить между <math>n</math> процессами. На вход каждому процессу подается своя вершина, далее происходит процедура поиска <math>k</math> ближайших соседей. Параллельная сложность составляет <math>O(n)</math>.

Второй и третий этапы можно распараллелить частично.

Второй этап распараллеливается путем подачи на вход свободному процессу очередного подграфа для разделения. Число итераций оценивается в <math>O(n log(n))</math>.

Третий этап делится на расчет показателей схожести и соединение подграфов в кластеры. Процесс расчета показателей можно распараллелить, подавая каждому процессу на вход пару подграфов. Сложность этого процесса оценивается как <math>m log(m)</math>. Соединение подграфов в кластеры выполняется последовательно, сложность процесса составляет <math>m^2 log(m)</math>

Таким образом получаем общую параллельную сложность алгоритма: <math>O(n+ n log(n) + m^2 log (m) + m log(m))</math>

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

1. Симметрическая матрица <math>A</math> расстояний между элементами данных размера <math>n\times n</math> с нулями на главной диагонали (<math>a_{ii}= 0, i = 1, \ldots, N</math>).

2. <math>k</math> - количество ближайших соседей для вершин (рекомендуемое значение <math>k</math> от 5 до 20 в зависимости от количества анализируемых объектов).

3. <math>l</math> - наименьшее число вершин, которое может содержать наибольший подкластер на 2-м этапе . Величина этого параметра варьируется от 1 до 5 % от общего числа объектов.

'''Объём входных данных'''

<math>\frac{n (n - 1)}{2}</math> (в силу симметричности и нулевой главной диагонали достаточно хранить только над/поддиагональные элементы).

'''Выходные данные'''

Вектор из <math>n</math> чисел <math>u_{1}, u_{2}, \ldots, u_{N}</math>, где <math>u_{i}</math> - целое число, соответствующее кластеру <math>i</math>-го объекта.

'''Объём выходных данных'''

<math>n</math>

== Свойства алгоритма ==
Соотношение последовательной и параллельной сложности на первом этапе является ''линейным'' для больших наборов данных и логарифмическим для n вершин. На втором этапе сложно оценить это соотношение - оно сильно зависит от параметров <math>k</math> и <math>l</math>. На третьем этапе соотношение равно <math>O(1)</math>;

Оценка ''вычислительной мощности'' выглядит следующим образом:

<math>O(1)</math> для 1-го этапа;

<math>O(\frac{nm}{n^2+m^2})</math> для 2-го этапа;

<math>O(\frac{m^2log(m)}{m^2+n})</math> для 3-го этапа;

Алгоритм является ''недетерминированным''. Хотя 1-й этап детерминирован, на 2-ом этапе могут быть найдены различные разбиения на подграфы, что повлияет и на итоговый результат работы алгоритма.

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

Исследовалась масштабируемость параллельной реализации алгоритма для 4 и 8 потоков.<ref name="tr">http://research.ijcaonline.org/volume79/number8/pxc3891600.pdf</ref>

Результаты отображены в виде графика. Можно отметить, что с увеличением объема входных данных растут ускорение и эффективность работы алгоритма. Однако эффективность снижается при увеличении числа потоков.

[[File:Масштабирование.jpg|1000px|center]]

== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Последовательная реализация алгоритма доступна по ссылке <ref>http://read.pudn.com/downloads36/sourcecode/math/115779/chameleon/chameleon.c__.htm</ref>.

CHAMELEON можно реализовать с использованием графовых библиотек METIS <ref>http://glaros.dtc.umn.edu/gkhome/metis/metis/overview
</ref>, hMETIS <ref>http://glaros.dtc.umn.edu/gkhome/metis/hmetis/overview</ref> и RANN <ref>https://cran.r-project.org/web/packages/RANN/index.html</ref>.

Существует исследование, связанное с реализацией CHAMELEON посредством технологии OpenMP, оно было рассмотрено в пункте 2.4.

Параллельных реализаций алгоритма CHAMELEON не найдено.

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

Участник:ЕкатеринаКозырева/Алгоритм динамической иерархической кластеризации CHAMELEON

2016-12-16T22:40:09Z

ЕкатеринаКозырева: /* Возможные способы и особенности параллельной реализации алгоритма */

{{Assignment|Kronberg}}
{{algorithm
| name = Алгоритм динамической иерархической кластеризации CHAMELEON
| serial_complexity = <math>O(nm + n log n + m^2 log m)</math>
| input_data = <math>\frac{n (n - 1)}{2}</math>
| output_data = <math>n</math>
| pf_height = <math>O(n+ n log(n) + m^2 log (m) + m log(m))</math>
| pf_width = <math>O(n)</math>
}}

Автор описания [[Участник:ЕкатеринаКозырева|Е.А.Козырева]]
= Свойства и структура алгоритмов =

== Общее описание алгоритма ==
Алгоритм CHAMELEON был предложен в 1999 году тремя учеными из университета Миннесоты – George Karypis, Eui-Hong (Sam) Han и Vipin Kumar<ref>George Karypis, Eui-Hong (Sam) Han и Vipin Kumar, «Chameleon: Hierarchical Clustering Using Dynamic Modeling», 1999.</ref>.

Предназначен для решения задач кластеризации. Кластеризация (или кластерный анализ) — это задача разбиения множества объектов на группы, называемые кластерами. Внутри каждой группы должны оказаться «похожие» объекты, а объекты разных группы должны быть как можно более отличны.

CHAMELEON - это агломеративный иерархический алгоритм кластеризации, ключевой особенностью которого является то, что он учитывает и взаимную связность, и сходство при определении наиболее похожей пары подкластеров, основываясь на динамической модели. Это означает, что в процессе кластеризации два кластера объединяются, только если их относительная взаимная связность и относительное взаимное сходство являются высокими по отношению к внутренней взаимосвязанности кластеров и близости элементов внутри кластеров. Кроме того, CHAMELEON использует подход для моделирования степени взаимосвязанности и близости между каждой парой кластеров, который учитывает внутренние характеристики самих кластеров. Таким образом, он может автоматически адаптироваться к внутренним характеристикам объединяемых кластеров.

CHAMELEON находит кластеры в наборе данных с помощью трехфазного алгоритма. На первой фазе происходит построение графа, путём добавления рёбер по принципу k ближайших соседей. На второй фазе CHAMELEON группирует полученные элементы в множество относительно небольших подграфов. Во время третьей фазы применяется агломеративный иерархический алгоритм кластеризации, с помощью которого находятся естесственные кластеры путем многократного объединения подграфов, полученных на прошлом этапе.

[[File:Chameleon.png|1000px|thumb|center|Рисунок 1. Общая структура алгоритма CHAMELEON]]

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

''Исходные данные'':

* Множество из n точек <math>V= {v_{ij}}</math> в метрическом пространстве, которое задано симметрической матрицей расстояний <math>A</math> размера <math>n\times n</math>.
* <math>k</math> - количество ближайших соседей для вершин, <math>k \in N, k \leq n</math>.
* <math>l</math> - наименьшее число вершин, которое может содержать наибольший подграф на 2-м этапе, <math>l \in N, l \leq n</math>.

''Обозначения'':

* <math>G = (V, E)</math> - граф, полученный путём соединения каждой точки с её <math>k</math> ближайшими соседями.

* <math>K= \{K_{i}\}</math> - разбиение множества <math>V</math> на набор попарно непересекающихся связных подмножеств, полученное в результате выполнения второй фазы алгоритма.

* <math>G_{2} = (K, E_{2})</math> - взвешенный граф, вершинами которого являются получившиеся подграфы, а ребрами - количество ребер исходного графа, соединяющих соответствующие подграфы.

* <math>C = \{C_{i}\}</math> - итоговое разбиение множества вершин графа <math>G_{2}</math> на набор кластеров.

''Вспомогательные понятия''

*<math>EC_{(C_{i},C_{j})}</math> - абсолютная взаимная связность пары кластеров <math>C_{i}, C{j}</math>. Определяется как сумма весов ребер, соединяющих вершины, принадлежащие <math>C{i}</math> c вершинами из <math>C{j}</math>. Внутренняя связность <math>EC_{(C_{i},C_{i})}</math> вычисляется как сумма ребер, входящих в разделитель, разбивающий <math>C{i}</math> на два равных подграфа.

*<math>RI_{(C_{i},C_{j})} = \frac{|EC_{(C_{i},C_{j})}|}{(|EC_{C_{i}}|+|EC_{C_{j}}|)/2}</math> - относительная взаимная связность пары кластеров <math>C_{i}, C{j}</math>

*<math>S_{EC_{(C_{i},C_{j})}}</math> - абсолютное взаимное сходство пары кластеров <math>C_{i}, C{j}</math>. Подсчитывается как среднее сходство между соединенными вершинами, принадлежащими <math>C{i}</math> и <math>C{j}</math> соответственно. Соединения обусловлены разбиением общего графа, полученного на первом этапе алгоритма.

*<math> RC_{(C_{i},C_{j})}= \frac{S_{EC_{(C_{i},C_{j})}}}{\frac{|C_{i}|}{|C_{i}+C_{j}|}*S_{EC_{(C_{i})}}+\frac{|C_{i}|}{|C_{i}+C_{j}|}*S_{EC_{(C_{j})}}}</math> - относительное взаимное сходство пары кластеров <math>C_{i}, C{j}</math>. Определяется как абсолютное сходство между этой парой кластеров, нормализованное с учетом их внутреннего сходства<ref>http://studopedia.ru/7_41934_algoritm-dinamicheskoy-ierarhicheskoy-klasterizatsii-CHAMELEON.html</ref>.

'''Первый этап'''

На первом этапе, согласно графо-ориентированному подходу, происходит построение графа <math>G = (V, E)</math> на матрице сходства объектов по принципу k ближайших соседей. Две вершины такого графа соединяет ребро, если объект, соответствующий любой из этих вершин попадает в число k наиболее близких объектов для объекта, соответствующего другой вершине из данной пары.
[[Файл:Снимок chameleon 2.png|2000px|thumb|Рисунок 2. Объекты в пространстве - слева, граф по принципу 1-го ближайшего соседа - по центру, граф по принципу 3-х ближайших соседей - справа ]]

'''Второй этап'''

Алгоритм разделяет полученный граф на множество сравнительно малых подграфов <math>K= \{K_{i}\}</math>. Разделение происходит последовательно. На каждом шаге выбирается подграф, содержащий наибольшее число вершин. Этот граф разделяется на два подграфа так, что разделитель ребер графа минимален и каждый из получаемых подграфов содержит не менее 25 % вершин исходного графа. Процесс разделения останавливается, когда наибольший подграф содержит меньше некоторого заданного числа вершин. Обычно величина этого параметра задается равной значению от 1 до 5 % от числа объектов. Полученное множество связных графов считается множеством начальных кластеров, на котором требуется провести последовательное иерархическое объединение.

'''Третий этап'''

Третий этап заключается в итеративном преобразовании множества подграфов <math>K= \{K_{i}\}</math> в множество кластеров <math>C = \{C_{i}\}</math>. Алгоритм осуществляет агломеративную иерархическую кластеризацию на основании показателей <math>EC_{(C_{i},C_{j})}</math>, <math>S_{EC_{(C_{i},C_{j})}}</math>, <math>RI_{(C_{i},C_{j})} </math>, <math> RC_{(C_{i},C_{j})}</math>. Существует две стратегии анализа показателей сходства. Первая подразумевает наличие некоторых пороговых значений <math>T_{RI}</math> и <math>T_{RC}</math>. В соответствии с этой стратегией, алгоритм для каждого кластера <math>C_{i}</math> проверяет, отвечают ли смежные (наиболее близкие) ему кластеры условиям:

*<math>RI_{(C_{i},C_{j})} \geqslant T_{RI}</math>

*<math>RC_{(C_{i},C_{j})} \geqslant T_{RC}</math>

Если более одного смежного кластера отвечает этим условиям, то алгоритм выбирает для объединения наиболее связный кластер (граф), то есть такой кластер <math>C_{j}</math>, с которым у кластера <math>C_{i}</math> получается наибольшая абсолютная взаимная связность. По завершению прохода по всем кластерам, созданные таким образом пары объединяются. Параметры <math>T_{RI}</math> и <math>T_{RC}</math> могут использоваться для изменения характеристик получаемых кластеров.

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

<math>RI_{(C_{i},C_{j})}*RC_{(C_{i},C_{j})}^\alpha</math>,

где <math>\alpha</math> выбирается пользователем. Если <math>\alpha > 1 </math>, то алгоритм придает большее значение относительному взаимному сходству, а если <math>\alpha < 1 </math>, то большее значение имеет относительная взаимная связность.

''Вычисляемые данные'':

<math>U = (u_1, u_2, ..., u_n)</math> - n-мерный вектор, где <math>u_i \in N_{[C]}</math> - порядковый номер кластера, к которому принадлежит вершина i исходного множества V.

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

Алгоритм имеет три вычислительных ядра, по одному на каждый этап.

На первом этапе вычислительным ядром является процесс нахождения <math>k</math> ближайших соседей для каждой вершины, который заключается в анализе матрицы расстояний.

На втором этапе вычислительным ядром является процесс поиска подходящего разбиения очередного подграфа на два графа с минимизацией разделителя ребер графа.

На третьем этапе вычислительным ядром является расчет величин <math>EC_{(C_{i},C_{j})}</math>, <math>S_{EC_{(C_{i},C_{j})}}</math>, <math>RI_{(C_{i},C_{j})} </math>, <math> RC_{(C_{i},C_{j})}</math> для каждой пары смежных кластеров.

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

Как уже рассказывалось ранее, алгоритм включает в себя три основных этапа, каждый из которых, по сути, является отдельным алгоритмом. Этапы выполняются последовательно относительно друг друга.

Макрооперация на первом этапе - процедура нахождения <math>k</math> ближайших соседей, на втором - процедура разбиения наибольшего подграфа на два графа, на третьем - процедура вычисления показателей сходства, на основе которых принимается решение о слиянии подграфов в кластер.

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

'''Первый этап'''
<source lang="cpp">
int n; //количество вершин
int k; //количество соседей
int A[n][n] //матрица расстояний
int D[k] //массив вершин-соседей
int E[n][n] //матрица ребер графа <math>G_{2} = (K, E_{2})</math>
for i=1 to n-1 do
{
for j=i+1 to n do
{
//заполняем массив вершин-соседей вставляя новые вершины, если они ближе, чем самая далекая из массива.
}
for j=0 to k do
{
//для каждой вершины соседа заполняем соответствующую ячейку из матрицы E[n][n] единицей
}

}
</source>

'''Второй этап'''

1. Все связные подграфы в отсортированном порядке помещаются в список;
2. Берем наибольший элемент списка, вычисляем количество его вершин. Если число вершин > l, то идем в пункт 3. Иначе в пункт 5;
3. Разбиваем подграф на два подграфа таким образом, чтобы разделитель ребер графа был минимален и каждый из получаемых подграфов содержал не менее 25 % вершин исходного графа;
4. Добавляем полученные элементы в список подграфов таким образом, чтобы список оставался отсортированным. Идем в пункт 2;
5. Нашли искомое множество подграфов math>K = \{K_{i}\}</math>;
6. Создаем и заполняем матрицу матрицу расстояний для графа <math>G_{2} = (K, E_{2})</math>. Получаем искомый набор рёбер <math>E_{2}</math>.

'''Третий этап'''

1. Заводим два массива: а) массив кластеров C, полученных на предыдущем этапе, б) массив объединений кластеров F, которые мы будем получать на этом этапе;
2. Берем следующий кластер <math>C_{i}</math> (на первом шаге - первый). Если все кластеры просмотрены, идем в пункт 6;
3. Берем следующий кластер <math>C_{j}, i<>j</math>. Если все кластеры просмотрены, то идем в пункт 2;
4. Проверяем смежность <math>C_{i}</math> и <math>C_{j}</math>. Если не смежны, то возвращаемся в пункт 3. Если смежны, идем в пункт 5;
5. Рассчитываем показатели <math>RI_{(C_{i},C_{j})}</math> и <math> RC_{(C_{i},C_{j})}</math>. Проверяем, удовлетворяют ли найденные значения условиям:
*<math>RI_{(C_{i},C_{j})} \geqslant T_{RI}</math>
*<math>RC_{(C_{i},C_{j})} \geqslant T_{RC}</math>
Если нет, то идем в пункт 3. Иначе если смежность пары кластеров выше, чем у предыдущих найденных, то <math>F_{i}=j</math>. Идем в пункт 3;
6. Если в списке F есть хотя бы одна пара кластеров для слияния, то выполняем слияние, обновляем массив кластеров и массив объединений кластеров. Идем в пункт 2.

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

1) Для построения графа на основе метода k ближайших соседей для n вершин требуется <math>O(n log(n))</math> операций <ref>J.H. Friedman, J.L. Bentley, and R.A. Finkel. An algorithm for ﬁnding best matches in logarithmic expected time. ACM Transactions on Mathematical Software, 3:209–226, 1977.</ref>; для наборов данных большой размерности эта величина составляет <math>O(n^2)</math> операций <ref>S. Berchtold, C. Bohm, D. Keim, and H.-P. Kriegel. Cost model for nearest neighbor search in high dimensional data space. In Proc. of Symposium on Principles of Database Systems, Tucson, Arizona, 1997.</ref>;

2) Для выделения множества сравнительно малых связных подграфов требуется <math>nm</math> операций, где <math>m</math> - количество подграфов, полученных на втором этапе алгоритма;

3) Формирование набора кластеров, на основе множества подграфов, полученных на предыдущем этапе, требует <math>m^2log(m)</math> операций.

Итого, для n вершин получаем последовательную сложность <math>O(n log(n)+nm+m^2log(m))</math>.

== Информационный граф ==
[[File:СК.png]]

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

Первый этап работы алгоритма можно распределить между <math>n</math> процессами. На вход каждому процессу подается своя вершина, далее происходит процедура поиска <math>k</math> ближайших соседей. Параллельная сложность составляет <math>O(n)</math>.

Второй и третий этапы можно распараллелить частично.

Второй этап распараллеливается путем подачи на вход свободному процессу очередного подграфа для разделения. Число итераций оценивается в <math>O(n log(n))</math>.

Третий этап делится на расчет показателей схожести и соединение подграфов в кластеры. Процесс расчета показателей можно распараллелить, подавая каждому процессу на вход пару подграфов. Сложность этого процесса оценивается как <math>m log(m)</math>. Соединение подграфов в кластеры выполняется последовательно, сложность процесса составляет <math>m^2 log(m)</math>

Таким образом получаем общую параллельную сложность алгоритма: <math>O(n+ n log(n) + m^2 log (m) + m log(m))</math>

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

1. Симметрическая матрица <math>A</math> расстояний между элементами данных размера <math>n\times n</math> с нулями на главной диагонали (<math>a_{ii}= 0, i = 1, \ldots, N</math>).

2. <math>k</math> - количество ближайших соседей для вершин (рекомендуемое значение <math>k</math> от 5 до 20 в зависимости от количества анализируемых объектов).

3. <math>l</math> - наименьшее число вершин, которое может содержать наибольший подкластер на 2-м этапе . Величина этого параметра варьируется от 1 до 5 % от общего числа объектов.

'''Объём входных данных'''

<math>\frac{n (n - 1)}{2}</math> (в силу симметричности и нулевой главной диагонали достаточно хранить только над/поддиагональные элементы).

'''Выходные данные'''

Вектор из <math>n</math> чисел <math>u_{1}, u_{2}, \ldots, u_{N}</math>, где <math>u_{i}</math> - целое число, соответствующее кластеру <math>i</math>-го объекта.

'''Объём выходных данных'''

<math>n</math>

== Свойства алгоритма ==
Соотношение последовательной и параллельной сложности на первом этапе является ''линейным'' для больших наборов данных и логарифмическим для n вершин. На втором этапе сложно оценить это соотношение - оно сильно зависит от параметров <math>k</math> и <math>l</math>. На третьем этапе соотношение равно <math>O(1)</math>;

Оценка ''вычислительной мощности'' выглядит следующим образом:

<math>O(1)</math> для 1-го этапа;

<math>O(\frac{nm}{n^2+m^2})</math> для 2-го этапа;

<math>O(\frac{m^2log(m)}{m^2+n})</math> для 3-го этапа;

Алгоритм является ''недетерминированным''. Хотя 1-й этап детерминирован, на 2-ом этапе могут быть найдены различные разбиения на подграфы, что повлияет и на итоговый результат работы алгоритма.

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

Исследовалась масштабируемость параллельной реализации алгоритма для 4 и 8 потоков.<ref name="tr">http://research.ijcaonline.org/volume79/number8/pxc3891600.pdf</ref>

Результаты отображены в виде графика. Можно отметить, что с увеличением объема входных данных растут ускорение и эффективность работы алгоритма. Однако эффективность снижается при увеличении числа потоков.

[[File:Масштабирование.jpg|1000px|center]]

== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Последовательная реализация алгоритма доступна по ссылке <ref>http://read.pudn.com/downloads36/sourcecode/math/115779/chameleon/chameleon.c__.htm</ref>.

CHAMELEON можно реализовать с использованием графовых библиотек METIS <ref>http://glaros.dtc.umn.edu/gkhome/metis/metis/overview
</ref>, hMETIS <ref>http://glaros.dtc.umn.edu/gkhome/metis/hmetis/overview</ref> и RANN <ref>https://cran.r-project.org/web/packages/RANN/index.html</ref>.

Существует исследование, связанное с реализацией CHAMELEON посредством технологии OpenMP, оно было рассмотрено в пункте 2.4.

Параллельных реализаций алгоритма CHAMELEON не найдено.

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

Участник:ЕкатеринаКозырева/Алгоритм динамической иерархической кластеризации CHAMELEON

2016-12-16T22:39:45Z

ЕкатеринаКозырева: /* Масштабируемость алгоритма и его реализации */

{{Assignment|Kronberg}}
{{algorithm
| name = Алгоритм динамической иерархической кластеризации CHAMELEON
| serial_complexity = <math>O(nm + n log n + m^2 log m)</math>
| input_data = <math>\frac{n (n - 1)}{2}</math>
| output_data = <math>n</math>
| pf_height = <math>O(n+ n log(n) + m^2 log (m) + m log(m))</math>
| pf_width = <math>O(n)</math>
}}

Автор описания [[Участник:ЕкатеринаКозырева|Е.А.Козырева]]
= Свойства и структура алгоритмов =

== Общее описание алгоритма ==
Алгоритм CHAMELEON был предложен в 1999 году тремя учеными из университета Миннесоты – George Karypis, Eui-Hong (Sam) Han и Vipin Kumar<ref>George Karypis, Eui-Hong (Sam) Han и Vipin Kumar, «Chameleon: Hierarchical Clustering Using Dynamic Modeling», 1999.</ref>.

Предназначен для решения задач кластеризации. Кластеризация (или кластерный анализ) — это задача разбиения множества объектов на группы, называемые кластерами. Внутри каждой группы должны оказаться «похожие» объекты, а объекты разных группы должны быть как можно более отличны.

CHAMELEON - это агломеративный иерархический алгоритм кластеризации, ключевой особенностью которого является то, что он учитывает и взаимную связность, и сходство при определении наиболее похожей пары подкластеров, основываясь на динамической модели. Это означает, что в процессе кластеризации два кластера объединяются, только если их относительная взаимная связность и относительное взаимное сходство являются высокими по отношению к внутренней взаимосвязанности кластеров и близости элементов внутри кластеров. Кроме того, CHAMELEON использует подход для моделирования степени взаимосвязанности и близости между каждой парой кластеров, который учитывает внутренние характеристики самих кластеров. Таким образом, он может автоматически адаптироваться к внутренним характеристикам объединяемых кластеров.

CHAMELEON находит кластеры в наборе данных с помощью трехфазного алгоритма. На первой фазе происходит построение графа, путём добавления рёбер по принципу k ближайших соседей. На второй фазе CHAMELEON группирует полученные элементы в множество относительно небольших подграфов. Во время третьей фазы применяется агломеративный иерархический алгоритм кластеризации, с помощью которого находятся естесственные кластеры путем многократного объединения подграфов, полученных на прошлом этапе.

[[File:Chameleon.png|1000px|thumb|center|Рисунок 1. Общая структура алгоритма CHAMELEON]]

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

''Исходные данные'':

* Множество из n точек <math>V= {v_{ij}}</math> в метрическом пространстве, которое задано симметрической матрицей расстояний <math>A</math> размера <math>n\times n</math>.
* <math>k</math> - количество ближайших соседей для вершин, <math>k \in N, k \leq n</math>.
* <math>l</math> - наименьшее число вершин, которое может содержать наибольший подграф на 2-м этапе, <math>l \in N, l \leq n</math>.

''Обозначения'':

* <math>G = (V, E)</math> - граф, полученный путём соединения каждой точки с её <math>k</math> ближайшими соседями.

* <math>K= \{K_{i}\}</math> - разбиение множества <math>V</math> на набор попарно непересекающихся связных подмножеств, полученное в результате выполнения второй фазы алгоритма.

* <math>G_{2} = (K, E_{2})</math> - взвешенный граф, вершинами которого являются получившиеся подграфы, а ребрами - количество ребер исходного графа, соединяющих соответствующие подграфы.

* <math>C = \{C_{i}\}</math> - итоговое разбиение множества вершин графа <math>G_{2}</math> на набор кластеров.

''Вспомогательные понятия''

*<math>EC_{(C_{i},C_{j})}</math> - абсолютная взаимная связность пары кластеров <math>C_{i}, C{j}</math>. Определяется как сумма весов ребер, соединяющих вершины, принадлежащие <math>C{i}</math> c вершинами из <math>C{j}</math>. Внутренняя связность <math>EC_{(C_{i},C_{i})}</math> вычисляется как сумма ребер, входящих в разделитель, разбивающий <math>C{i}</math> на два равных подграфа.

*<math>RI_{(C_{i},C_{j})} = \frac{|EC_{(C_{i},C_{j})}|}{(|EC_{C_{i}}|+|EC_{C_{j}}|)/2}</math> - относительная взаимная связность пары кластеров <math>C_{i}, C{j}</math>

*<math>S_{EC_{(C_{i},C_{j})}}</math> - абсолютное взаимное сходство пары кластеров <math>C_{i}, C{j}</math>. Подсчитывается как среднее сходство между соединенными вершинами, принадлежащими <math>C{i}</math> и <math>C{j}</math> соответственно. Соединения обусловлены разбиением общего графа, полученного на первом этапе алгоритма.

*<math> RC_{(C_{i},C_{j})}= \frac{S_{EC_{(C_{i},C_{j})}}}{\frac{|C_{i}|}{|C_{i}+C_{j}|}*S_{EC_{(C_{i})}}+\frac{|C_{i}|}{|C_{i}+C_{j}|}*S_{EC_{(C_{j})}}}</math> - относительное взаимное сходство пары кластеров <math>C_{i}, C{j}</math>. Определяется как абсолютное сходство между этой парой кластеров, нормализованное с учетом их внутреннего сходства<ref>http://studopedia.ru/7_41934_algoritm-dinamicheskoy-ierarhicheskoy-klasterizatsii-CHAMELEON.html</ref>.

'''Первый этап'''

На первом этапе, согласно графо-ориентированному подходу, происходит построение графа <math>G = (V, E)</math> на матрице сходства объектов по принципу k ближайших соседей. Две вершины такого графа соединяет ребро, если объект, соответствующий любой из этих вершин попадает в число k наиболее близких объектов для объекта, соответствующего другой вершине из данной пары.
[[Файл:Снимок chameleon 2.png|2000px|thumb|Рисунок 2. Объекты в пространстве - слева, граф по принципу 1-го ближайшего соседа - по центру, граф по принципу 3-х ближайших соседей - справа ]]

'''Второй этап'''

Алгоритм разделяет полученный граф на множество сравнительно малых подграфов <math>K= \{K_{i}\}</math>. Разделение происходит последовательно. На каждом шаге выбирается подграф, содержащий наибольшее число вершин. Этот граф разделяется на два подграфа так, что разделитель ребер графа минимален и каждый из получаемых подграфов содержит не менее 25 % вершин исходного графа. Процесс разделения останавливается, когда наибольший подграф содержит меньше некоторого заданного числа вершин. Обычно величина этого параметра задается равной значению от 1 до 5 % от числа объектов. Полученное множество связных графов считается множеством начальных кластеров, на котором требуется провести последовательное иерархическое объединение.

'''Третий этап'''

Третий этап заключается в итеративном преобразовании множества подграфов <math>K= \{K_{i}\}</math> в множество кластеров <math>C = \{C_{i}\}</math>. Алгоритм осуществляет агломеративную иерархическую кластеризацию на основании показателей <math>EC_{(C_{i},C_{j})}</math>, <math>S_{EC_{(C_{i},C_{j})}}</math>, <math>RI_{(C_{i},C_{j})} </math>, <math> RC_{(C_{i},C_{j})}</math>. Существует две стратегии анализа показателей сходства. Первая подразумевает наличие некоторых пороговых значений <math>T_{RI}</math> и <math>T_{RC}</math>. В соответствии с этой стратегией, алгоритм для каждого кластера <math>C_{i}</math> проверяет, отвечают ли смежные (наиболее близкие) ему кластеры условиям:

*<math>RI_{(C_{i},C_{j})} \geqslant T_{RI}</math>

*<math>RC_{(C_{i},C_{j})} \geqslant T_{RC}</math>

Если более одного смежного кластера отвечает этим условиям, то алгоритм выбирает для объединения наиболее связный кластер (граф), то есть такой кластер <math>C_{j}</math>, с которым у кластера <math>C_{i}</math> получается наибольшая абсолютная взаимная связность. По завершению прохода по всем кластерам, созданные таким образом пары объединяются. Параметры <math>T_{RI}</math> и <math>T_{RC}</math> могут использоваться для изменения характеристик получаемых кластеров.

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

<math>RI_{(C_{i},C_{j})}*RC_{(C_{i},C_{j})}^\alpha</math>,

где <math>\alpha</math> выбирается пользователем. Если <math>\alpha > 1 </math>, то алгоритм придает большее значение относительному взаимному сходству, а если <math>\alpha < 1 </math>, то большее значение имеет относительная взаимная связность.

''Вычисляемые данные'':

<math>U = (u_1, u_2, ..., u_n)</math> - n-мерный вектор, где <math>u_i \in N_{[C]}</math> - порядковый номер кластера, к которому принадлежит вершина i исходного множества V.

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

Алгоритм имеет три вычислительных ядра, по одному на каждый этап.

На первом этапе вычислительным ядром является процесс нахождения <math>k</math> ближайших соседей для каждой вершины, который заключается в анализе матрицы расстояний.

На втором этапе вычислительным ядром является процесс поиска подходящего разбиения очередного подграфа на два графа с минимизацией разделителя ребер графа.

На третьем этапе вычислительным ядром является расчет величин <math>EC_{(C_{i},C_{j})}</math>, <math>S_{EC_{(C_{i},C_{j})}}</math>, <math>RI_{(C_{i},C_{j})} </math>, <math> RC_{(C_{i},C_{j})}</math> для каждой пары смежных кластеров.

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

Как уже рассказывалось ранее, алгоритм включает в себя три основных этапа, каждый из которых, по сути, является отдельным алгоритмом. Этапы выполняются последовательно относительно друг друга.

Макрооперация на первом этапе - процедура нахождения <math>k</math> ближайших соседей, на втором - процедура разбиения наибольшего подграфа на два графа, на третьем - процедура вычисления показателей сходства, на основе которых принимается решение о слиянии подграфов в кластер.

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

'''Первый этап'''
<source lang="cpp">
int n; //количество вершин
int k; //количество соседей
int A[n][n] //матрица расстояний
int D[k] //массив вершин-соседей
int E[n][n] //матрица ребер графа <math>G_{2} = (K, E_{2})</math>
for i=1 to n-1 do
{
for j=i+1 to n do
{
//заполняем массив вершин-соседей вставляя новые вершины, если они ближе, чем самая далекая из массива.
}
for j=0 to k do
{
//для каждой вершины соседа заполняем соответствующую ячейку из матрицы E[n][n] единицей
}

}
</source>

'''Второй этап'''

1. Все связные подграфы в отсортированном порядке помещаются в список;
2. Берем наибольший элемент списка, вычисляем количество его вершин. Если число вершин > l, то идем в пункт 3. Иначе в пункт 5;
3. Разбиваем подграф на два подграфа таким образом, чтобы разделитель ребер графа был минимален и каждый из получаемых подграфов содержал не менее 25 % вершин исходного графа;
4. Добавляем полученные элементы в список подграфов таким образом, чтобы список оставался отсортированным. Идем в пункт 2;
5. Нашли искомое множество подграфов math>K = \{K_{i}\}</math>;
6. Создаем и заполняем матрицу матрицу расстояний для графа <math>G_{2} = (K, E_{2})</math>. Получаем искомый набор рёбер <math>E_{2}</math>.

'''Третий этап'''

1. Заводим два массива: а) массив кластеров C, полученных на предыдущем этапе, б) массив объединений кластеров F, которые мы будем получать на этом этапе;
2. Берем следующий кластер <math>C_{i}</math> (на первом шаге - первый). Если все кластеры просмотрены, идем в пункт 6;
3. Берем следующий кластер <math>C_{j}, i<>j</math>. Если все кластеры просмотрены, то идем в пункт 2;
4. Проверяем смежность <math>C_{i}</math> и <math>C_{j}</math>. Если не смежны, то возвращаемся в пункт 3. Если смежны, идем в пункт 5;
5. Рассчитываем показатели <math>RI_{(C_{i},C_{j})}</math> и <math> RC_{(C_{i},C_{j})}</math>. Проверяем, удовлетворяют ли найденные значения условиям:
*<math>RI_{(C_{i},C_{j})} \geqslant T_{RI}</math>
*<math>RC_{(C_{i},C_{j})} \geqslant T_{RC}</math>
Если нет, то идем в пункт 3. Иначе если смежность пары кластеров выше, чем у предыдущих найденных, то <math>F_{i}=j</math>. Идем в пункт 3;
6. Если в списке F есть хотя бы одна пара кластеров для слияния, то выполняем слияние, обновляем массив кластеров и массив объединений кластеров. Идем в пункт 2.

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

1) Для построения графа на основе метода k ближайших соседей для n вершин требуется <math>O(n log(n))</math> операций <ref>J.H. Friedman, J.L. Bentley, and R.A. Finkel. An algorithm for ﬁnding best matches in logarithmic expected time. ACM Transactions on Mathematical Software, 3:209–226, 1977.</ref>; для наборов данных большой размерности эта величина составляет <math>O(n^2)</math> операций <ref>S. Berchtold, C. Bohm, D. Keim, and H.-P. Kriegel. Cost model for nearest neighbor search in high dimensional data space. In Proc. of Symposium on Principles of Database Systems, Tucson, Arizona, 1997.</ref>;

2) Для выделения множества сравнительно малых связных подграфов требуется <math>nm</math> операций, где <math>m</math> - количество подграфов, полученных на втором этапе алгоритма;

3) Формирование набора кластеров, на основе множества подграфов, полученных на предыдущем этапе, требует <math>m^2log(m)</math> операций.

Итого, для n вершин получаем последовательную сложность <math>O(n log(n)+nm+m^2log(m))</math>.

== Информационный граф ==
[[File:СК.png]]

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

Первый этап работы алгоритма можно распределить между <math>n</math> процессами. На вход каждому процессу подается своя вершина, далее происходит процедура поиска <math>k</math> ближайших соседей. Параллельная сложность составляет <math>O(n)</math>.

Второй и третий этапы можно распараллелить частично.

Второй этап распараллеливается путем подачи на вход свободному процессу очередного подграфа для разделения. Число итераций оценивается в <math>O(n log(n))</math>.

Третий этап делится на расчет показателей схожести и соединение подграфов в кластеры. Процесс расчета показателей можно распараллелить, подавая каждому процессу на вход пару подграфов. Сложность этого процесса оценивается как <math>m log(m)</math>. Соединение подграфов в кластеры выполняется последовательно, сложность процесса составляет <math>m^2 log(m)</math>

Таким образом получаем общую параллельную сложность алгоритма: <math>O(n+ n log(n) + m^2 log (m) + m log(m))</math>

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

1. Симметрическая матрица <math>A</math> расстояний между элементами данных размера <math>n\times n</math> с нулями на главной диагонали (<math>a_{ii}= 0, i = 1, \ldots, N</math>).

2. <math>k</math> - количество ближайших соседей для вершин (рекомендуемое значение <math>k</math> от 5 до 20 в зависимости от количества анализируемых объектов).

3. <math>l</math> - наименьшее число вершин, которое может содержать наибольший подкластер на 2-м этапе . Величина этого параметра варьируется от 1 до 5 % от общего числа объектов.

'''Объём входных данных'''

<math>\frac{n (n - 1)}{2}</math> (в силу симметричности и нулевой главной диагонали достаточно хранить только над/поддиагональные элементы).

'''Выходные данные'''

Вектор из <math>n</math> чисел <math>u_{1}, u_{2}, \ldots, u_{N}</math>, где <math>u_{i}</math> - целое число, соответствующее кластеру <math>i</math>-го объекта.

'''Объём выходных данных'''

<math>n</math>

== Свойства алгоритма ==
Соотношение последовательной и параллельной сложности на первом этапе является ''линейным'' для больших наборов данных и логарифмическим для n вершин. На втором этапе сложно оценить это соотношение - оно сильно зависит от параметров <math>k</math> и <math>l</math>. На третьем этапе соотношение равно <math>O(1)</math>;

Оценка ''вычислительной мощности'' выглядит следующим образом:

<math>O(1)</math> для 1-го этапа;

<math>O(\frac{nm}{n^2+m^2})</math> для 2-го этапа;

<math>O(\frac{m^2log(m)}{m^2+n})</math> для 3-го этапа;

Алгоритм является ''недетерминированным''. Хотя 1-й этап детерминирован, на 2-ом этапе могут быть найдены различные разбиения на подграфы, что повлияет и на итоговый результат работы алгоритма.

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

Исследовалась масштабируемость параллельной реализации алгоритма для 4 и 8 потоков.<ref name="tr">http://research.ijcaonline.org/volume79/number8/pxc3891600.pdf</ref>

Результаты отображены в виде графика. Можно отметить, что с увеличением объема входных данных растут ускорение и эффективность работы алгоритма. Однако эффективность снижается при увеличении числа потоков.

[[File:Масштабирование.jpg|700px|center]]

== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Последовательная реализация алгоритма доступна по ссылке <ref>http://read.pudn.com/downloads36/sourcecode/math/115779/chameleon/chameleon.c__.htm</ref>.

CHAMELEON можно реализовать с использованием графовых библиотек METIS <ref>http://glaros.dtc.umn.edu/gkhome/metis/metis/overview
</ref>, hMETIS <ref>http://glaros.dtc.umn.edu/gkhome/metis/hmetis/overview</ref> и RANN <ref>https://cran.r-project.org/web/packages/RANN/index.html</ref>.

Существует исследование, связанное с реализацией CHAMELEON посредством технологии OpenMP, оно было рассмотрено в пункте 2.4.

Параллельных реализаций алгоритма CHAMELEON не найдено.

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

Участник:ЕкатеринаКозырева/Алгоритм динамической иерархической кластеризации CHAMELEON

2016-12-05T13:00:10Z

ЕкатеринаКозырева: /* Масштабируемость алгоритма и его реализации */

{{Assignment|Kronberg}}
{{algorithm
| name = Алгоритм динамической иерархической кластеризации CHAMELEON
| serial_complexity = <math>O(nm + n log n + m^2 log m)</math>
| input_data = <math>\frac{n (n - 1)}{2}</math>
| output_data = <math>n</math>
| pf_height = <math>O(n+ n log(n) + m^2 log (m) + m log(m))</math>
| pf_width = <math>O(n)</math>
}}

Автор описания [[Участник:ЕкатеринаКозырева|Е.А.Козырева]]
= Свойства и структура алгоритмов =

== Общее описание алгоритма ==
Алгоритм CHAMELEON был предложен в 1999 году тремя учеными из университета Миннесоты – George Karypis, Eui-Hong (Sam) Han и Vipin Kumar<ref>George Karypis, Eui-Hong (Sam) Han и Vipin Kumar, «Chameleon: Hierarchical Clustering Using Dynamic Modeling», 1999.</ref>.

Предназначен для решения задач кластеризации. Кластеризация (или кластерный анализ) — это задача разбиения множества объектов на группы, называемые кластерами. Внутри каждой группы должны оказаться «похожие» объекты, а объекты разных группы должны быть как можно более отличны.

CHAMELEON - это агломеративный иерархический алгоритм кластеризации, ключевой особенностью которого является то, что он учитывает и взаимную связность, и сходство при определении наиболее похожей пары подкластеров, основываясь на динамической модели. Это означает, что в процессе кластеризации два кластера объединяются, только если их относительная взаимная связность и относительное взаимное сходство являются высокими по отношению к внутренней взаимосвязанности кластеров и близости элементов внутри кластеров. Кроме того, CHAMELEON использует подход для моделирования степени взаимосвязанности и близости между каждой парой кластеров, который учитывает внутренние характеристики самих кластеров. Таким образом, он может автоматически адаптироваться к внутренним характеристикам объединяемых кластеров.

CHAMELEON находит кластеры в наборе данных с помощью трехфазного алгоритма. На первой фазе происходит построение графа, путём добавления рёбер по принципу k ближайших соседей. На второй фазе CHAMELEON группирует полученные элементы в множество относительно небольших подграфов. Во время третьей фазы применяется агломеративный иерархический алгоритм кластеризации, с помощью которого находятся естесственные кластеры путем многократного объединения подграфов, полученных на прошлом этапе.

[[File:Chameleon.png|1000px|thumb|center|Рисунок 1. Общая структура алгоритма CHAMELEON]]

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

''Исходные данные'':

* Множество из n точек <math>V= {v_{ij}}</math> в метрическом пространстве, которое задано симметрической матрицей расстояний <math>A</math> размера <math>n\times n</math>.
* <math>k</math> - количество ближайших соседей для вершин, <math>k \in N, k \leq n</math>.
* <math>l</math> - наименьшее число вершин, которое может содержать наибольший подграф на 2-м этапе, <math>l \in N, l \leq n</math>.

''Обозначения'':

* <math>G = (V, E)</math> - граф, полученный путём соединения каждой точки с её <math>k</math> ближайшими соседями.

* <math>K= \{K_{i}\}</math> - разбиение множества <math>V</math> на набор попарно непересекающихся связных подмножеств, полученное в результате выполнения второй фазы алгоритма.

* <math>G_{2} = (K, E_{2})</math> - взвешенный граф, вершинами которого являются получившиеся подграфы, а ребрами - количество ребер исходного графа, соединяющих соответствующие подграфы.

* <math>C = \{C_{i}\}</math> - итоговое разбиение множества вершин графа <math>G_{2}</math> на набор кластеров.

''Вспомогательные понятия''

*<math>EC_{(C_{i},C_{j})}</math> - абсолютная взаимная связность пары кластеров <math>C_{i}, C{j}</math>. Определяется как сумма весов ребер, соединяющих вершины, принадлежащие <math>C{i}</math> c вершинами из <math>C{j}</math>. Внутренняя связность <math>EC_{(C_{i},C_{i})}</math> вычисляется как сумма ребер, входящих в разделитель, разбивающий <math>C{i}</math> на два равных подграфа.

*<math>RI_{(C_{i},C_{j})} = \frac{|EC_{(C_{i},C_{j})}|}{(|EC_{C_{i}}|+|EC_{C_{j}}|)/2}</math> - относительная взаимная связность пары кластеров <math>C_{i}, C{j}</math>

*<math>S_{EC_{(C_{i},C_{j})}}</math> - абсолютное взаимное сходство пары кластеров <math>C_{i}, C{j}</math>. Подсчитывается как среднее сходство между соединенными вершинами, принадлежащими <math>C{i}</math> и <math>C{j}</math> соответственно. Соединения обусловлены разбиением общего графа, полученного на первом этапе алгоритма.

*<math> RC_{(C_{i},C_{j})}= \frac{S_{EC_{(C_{i},C_{j})}}}{\frac{|C_{i}|}{|C_{i}+C_{j}|}*S_{EC_{(C_{i})}}+\frac{|C_{i}|}{|C_{i}+C_{j}|}*S_{EC_{(C_{j})}}}</math> - относительное взаимное сходство пары кластеров <math>C_{i}, C{j}</math>. Определяется как абсолютное сходство между этой парой кластеров, нормализованное с учетом их внутреннего сходства<ref>http://studopedia.ru/7_41934_algoritm-dinamicheskoy-ierarhicheskoy-klasterizatsii-CHAMELEON.html</ref>.

'''Первый этап'''

На первом этапе, согласно графо-ориентированному подходу, происходит построение графа <math>G = (V, E)</math> на матрице сходства объектов по принципу k ближайших соседей. Две вершины такого графа соединяет ребро, если объект, соответствующий любой из этих вершин попадает в число k наиболее близких объектов для объекта, соответствующего другой вершине из данной пары.
[[Файл:Снимок chameleon 2.png|2000px|thumb|Рисунок 2. Объекты в пространстве - слева, граф по принципу 1-го ближайшего соседа - по центру, граф по принципу 3-х ближайших соседей - справа ]]

'''Второй этап'''

Алгоритм разделяет полученный граф на множество сравнительно малых подграфов <math>K= \{K_{i}\}</math>. Разделение происходит последовательно. На каждом шаге выбирается подграф, содержащий наибольшее число вершин. Этот граф разделяется на два подграфа так, что разделитель ребер графа минимален и каждый из получаемых подграфов содержит не менее 25 % вершин исходного графа. Процесс разделения останавливается, когда наибольший подграф содержит меньше некоторого заданного числа вершин. Обычно величина этого параметра задается равной значению от 1 до 5 % от числа объектов. Полученное множество связных графов считается множеством начальных кластеров, на котором требуется провести последовательное иерархическое объединение.

'''Третий этап'''

Третий этап заключается в итеративном преобразовании множества подграфов <math>K= \{K_{i}\}</math> в множество кластеров <math>C = \{C_{i}\}</math>. Алгоритм осуществляет агломеративную иерархическую кластеризацию на основании показателей <math>EC_{(C_{i},C_{j})}</math>, <math>S_{EC_{(C_{i},C_{j})}}</math>, <math>RI_{(C_{i},C_{j})} </math>, <math> RC_{(C_{i},C_{j})}</math>. Существует две стратегии анализа показателей сходства. Первая подразумевает наличие некоторых пороговых значений <math>T_{RI}</math> и <math>T_{RC}</math>. В соответствии с этой стратегией, алгоритм для каждого кластера <math>C_{i}</math> проверяет, отвечают ли смежные (наиболее близкие) ему кластеры условиям:

*<math>RI_{(C_{i},C_{j})} \geqslant T_{RI}</math>

*<math>RC_{(C_{i},C_{j})} \geqslant T_{RC}</math>

Если более одного смежного кластера отвечает этим условиям, то алгоритм выбирает для объединения наиболее связный кластер (граф), то есть такой кластер <math>C_{j}</math>, с которым у кластера <math>C_{i}</math> получается наибольшая абсолютная взаимная связность. По завершению прохода по всем кластерам, созданные таким образом пары объединяются. Параметры <math>T_{RI}</math> и <math>T_{RC}</math> могут использоваться для изменения характеристик получаемых кластеров.

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

<math>RI_{(C_{i},C_{j})}*RC_{(C_{i},C_{j})}^\alpha</math>,

где <math>\alpha</math> выбирается пользователем. Если <math>\alpha > 1 </math>, то алгоритм придает большее значение относительному взаимному сходству, а если <math>\alpha < 1 </math>, то большее значение имеет относительная взаимная связность.

''Вычисляемые данные'':

<math>U = (u_1, u_2, ..., u_n)</math> - n-мерный вектор, где <math>u_i \in N_{[C]}</math> - порядковый номер кластера, к которому принадлежит вершина i исходного множества V.

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

Алгоритм имеет три вычислительных ядра, по одному на каждый этап.

На первом этапе вычислительным ядром является процесс нахождения <math>k</math> ближайших соседей для каждой вершины, который заключается в анализе матрицы расстояний.

На втором этапе вычислительным ядром является процесс поиска подходящего разбиения очередного подграфа на два графа с минимизацией разделителя ребер графа.

На третьем этапе вычислительным ядром является расчет величин <math>EC_{(C_{i},C_{j})}</math>, <math>S_{EC_{(C_{i},C_{j})}}</math>, <math>RI_{(C_{i},C_{j})} </math>, <math> RC_{(C_{i},C_{j})}</math> для каждой пары смежных кластеров.

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

Как уже рассказывалось ранее, алгоритм включает в себя три основных этапа, каждый из которых, по сути, является отдельным алгоритмом. Этапы выполняются последовательно относительно друг друга.

Макрооперация на первом этапе - процедура нахождения <math>k</math> ближайших соседей, на втором - процедура разбиения наибольшего подграфа на два графа, на третьем - процедура вычисления показателей сходства, на основе которых принимается решение о слиянии подграфов в кластер.

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

'''Первый этап'''
<source lang="cpp">
int n; //количество вершин
int k; //количество соседей
int A[n][n] //матрица расстояний
int D[k] //массив вершин-соседей
int E[n][n] //матрица ребер графа <math>G_{2} = (K, E_{2})</math>
for i=1 to n-1 do
{
for j=i+1 to n do
{
//заполняем массив вершин-соседей вставляя новые вершины, если они ближе, чем самая далекая из массива.
}
for j=0 to k do
{
//для каждой вершины соседа заполняем соответствующую ячейку из матрицы E[n][n] единицей
}

}
</source>

'''Второй этап'''

1. Все связные подграфы в отсортированном порядке помещаются в список;
2. Берем наибольший элемент списка, вычисляем количество его вершин. Если число вершин > l, то идем в пункт 3. Иначе в пункт 5;
3. Разбиваем подграф на два подграфа таким образом, чтобы разделитель ребер графа был минимален и каждый из получаемых подграфов содержал не менее 25 % вершин исходного графа;
4. Добавляем полученные элементы в список подграфов таким образом, чтобы список оставался отсортированным. Идем в пункт 2;
5. Нашли искомое множество подграфов math>K = \{K_{i}\}</math>;
6. Создаем и заполняем матрицу матрицу расстояний для графа <math>G_{2} = (K, E_{2})</math>. Получаем искомый набор рёбер <math>E_{2}</math>.

'''Третий этап'''

1. Заводим два массива: а) массив кластеров C, полученных на предыдущем этапе, б) массив объединений кластеров F, которые мы будем получать на этом этапе;
2. Берем следующий кластер <math>C_{i}</math> (на первом шаге - первый). Если все кластеры просмотрены, идем в пункт 6;
3. Берем следующий кластер <math>C_{j}, i<>j</math>. Если все кластеры просмотрены, то идем в пункт 2;
4. Проверяем смежность <math>C_{i}</math> и <math>C_{j}</math>. Если не смежны, то возвращаемся в пункт 3. Если смежны, идем в пункт 5;
5. Рассчитываем показатели <math>RI_{(C_{i},C_{j})}</math> и <math> RC_{(C_{i},C_{j})}</math>. Проверяем, удовлетворяют ли найденные значения условиям:
*<math>RI_{(C_{i},C_{j})} \geqslant T_{RI}</math>
*<math>RC_{(C_{i},C_{j})} \geqslant T_{RC}</math>
Если нет, то идем в пункт 3. Иначе если смежность пары кластеров выше, чем у предыдущих найденных, то <math>F_{i}=j</math>. Идем в пункт 3;
6. Если в списке F есть хотя бы одна пара кластеров для слияния, то выполняем слияние, обновляем массив кластеров и массив объединений кластеров. Идем в пункт 2.

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

1) Для построения графа на основе метода k ближайших соседей для n вершин требуется <math>O(n log(n))</math> операций <ref>J.H. Friedman, J.L. Bentley, and R.A. Finkel. An algorithm for ﬁnding best matches in logarithmic expected time. ACM Transactions on Mathematical Software, 3:209–226, 1977.</ref>; для наборов данных большой размерности эта величина составляет <math>O(n^2)</math> операций <ref>S. Berchtold, C. Bohm, D. Keim, and H.-P. Kriegel. Cost model for nearest neighbor search in high dimensional data space. In Proc. of Symposium on Principles of Database Systems, Tucson, Arizona, 1997.</ref>;

2) Для выделения множества сравнительно малых связных подграфов требуется <math>nm</math> операций, где <math>m</math> - количество подграфов, полученных на втором этапе алгоритма;

3) Формирование набора кластеров, на основе множества подграфов, полученных на предыдущем этапе, требует <math>m^2log(m)</math> операций.

Итого, для n вершин получаем последовательную сложность <math>O(n log(n)+nm+m^2log(m))</math>.

== Информационный граф ==
[[File:СК.png]]

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

Первый этап работы алгоритма можно распределить между <math>n</math> процессами. На вход каждому процессу подается своя вершина, далее происходит процедура поиска <math>k</math> ближайших соседей. Параллельная сложность составляет <math>O(n)</math>.

Второй и третий этапы можно распараллелить частично.

Второй этап распараллеливается путем подачи на вход свободному процессу очередного подграфа для разделения. Число итераций оценивается в <math>O(n log(n))</math>.

Третий этап делится на расчет показателей схожести и соединение подграфов в кластеры. Процесс расчета показателей можно распараллелить, подавая каждому процессу на вход пару подграфов. Сложность этого процесса оценивается как <math>m log(m)</math>. Соединение подграфов в кластеры выполняется последовательно, сложность процесса составляет <math>m^2 log(m)</math>

Таким образом получаем общую параллельную сложность алгоритма: <math>O(n+ n log(n) + m^2 log (m) + m log(m))</math>

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

1. Симметрическая матрица <math>A</math> расстояний между элементами данных размера <math>n\times n</math> с нулями на главной диагонали (<math>a_{ii}= 0, i = 1, \ldots, N</math>).

2. <math>k</math> - количество ближайших соседей для вершин (рекомендуемое значение <math>k</math> от 5 до 20 в зависимости от количества анализируемых объектов).

3. <math>l</math> - наименьшее число вершин, которое может содержать наибольший подкластер на 2-м этапе . Величина этого параметра варьируется от 1 до 5 % от общего числа объектов.

'''Объём входных данных'''

<math>\frac{n (n - 1)}{2}</math> (в силу симметричности и нулевой главной диагонали достаточно хранить только над/поддиагональные элементы).

'''Выходные данные'''

Вектор из <math>n</math> чисел <math>u_{1}, u_{2}, \ldots, u_{N}</math>, где <math>u_{i}</math> - целое число, соответствующее кластеру <math>i</math>-го объекта.

'''Объём выходных данных'''

<math>n</math>

== Свойства алгоритма ==
Соотношение последовательной и параллельной сложности на первом этапе является ''линейным'' для больших наборов данных и логарифмическим для n вершин. На втором этапе сложно оценить это соотношение - оно сильно зависит от параметров <math>k</math> и <math>l</math>. На третьем этапе соотношение равно <math>O(1)</math>;

Оценка ''вычислительной мощности'' выглядит следующим образом:

<math>O(1)</math> для 1-го этапа;

<math>O(\frac{nm}{n^2+m^2})</math> для 2-го этапа;

<math>O(\frac{m^2log(m)}{m^2+n})</math> для 3-го этапа;

Алгоритм является ''недетерминированным''. Хотя 1-й этап детерминирован, на 2-ом этапе могут быть найдены различные разбиения на подграфы, что повлияет и на итоговый результат работы алгоритма.

= Программная реализация алгоритма =
== Особенности реализации последовательного алгоритма ==
== Локальность данных и вычислений ==
== Возможные способы и особенности параллельной реализации алгоритма ==
== Масштабируемость алгоритма и его реализации ==
Было проведено исследование эффективности пробной версии параллельной реализации алгоритма<ref>http://research.ijcaonline.org/volume79/number8/pxc3891600.pdf</ref>. Полученные результаты отображены на графике(Рис.3).

По рисунку видно, что с ростом объема данных ускорение и эффективность алгоритма увеличиваются. Однако с ростом числа потоков эффективность уменьшается.

[[File:Масштабирование.jpg|thumb|700px|center|Рис.3 Масштабируемость алгоритма динамической иерархической кластеризации CHAMELEON в зависимости от числа процессоров и размера задачи]]

== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Последовательная реализация алгоритма доступна по ссылке <ref>http://read.pudn.com/downloads36/sourcecode/math/115779/chameleon/chameleon.c__.htm</ref>.

CHAMELEON можно реализовать с использованием графовых библиотек METIS <ref>http://glaros.dtc.umn.edu/gkhome/metis/metis/overview
</ref>, hMETIS <ref>http://glaros.dtc.umn.edu/gkhome/metis/hmetis/overview</ref> и RANN <ref>https://cran.r-project.org/web/packages/RANN/index.html</ref>.

Существует исследование, связанное с реализацией CHAMELEON посредством технологии OpenMP, оно было рассмотрено в пункте 2.4.

Параллельных реализаций алгоритма CHAMELEON не найдено.

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

Участник:ЕкатеринаКозырева/Алгоритм динамической иерархической кластеризации CHAMELEON

2016-12-05T12:50:25Z

ЕкатеринаКозырева: /* Масштабируемость алгоритма и его реализации */

{{Assignment|Kronberg}}
{{algorithm
| name = Алгоритм динамической иерархической кластеризации CHAMELEON
| serial_complexity = <math>O(nm + n log n + m^2 log m)</math>
| input_data = <math>\frac{n (n - 1)}{2}</math>
| output_data = <math>n</math>
| pf_height = <math>O(n+ n log(n) + m^2 log (m) + m log(m))</math>
| pf_width = <math>O(n)</math>
}}

Автор описания [[Участник:ЕкатеринаКозырева|Е.А.Козырева]]
= Свойства и структура алгоритмов =

== Общее описание алгоритма ==
Алгоритм CHAMELEON был предложен в 1999 году тремя учеными из университета Миннесоты – George Karypis, Eui-Hong (Sam) Han и Vipin Kumar<ref>George Karypis, Eui-Hong (Sam) Han и Vipin Kumar, «Chameleon: Hierarchical Clustering Using Dynamic Modeling», 1999.</ref>.

Предназначен для решения задач кластеризации. Кластеризация (или кластерный анализ) — это задача разбиения множества объектов на группы, называемые кластерами. Внутри каждой группы должны оказаться «похожие» объекты, а объекты разных группы должны быть как можно более отличны.

CHAMELEON - это агломеративный иерархический алгоритм кластеризации, ключевой особенностью которого является то, что он учитывает и взаимную связность, и сходство при определении наиболее похожей пары подкластеров, основываясь на динамической модели. Это означает, что в процессе кластеризации два кластера объединяются, только если их относительная взаимная связность и относительное взаимное сходство являются высокими по отношению к внутренней взаимосвязанности кластеров и близости элементов внутри кластеров. Кроме того, CHAMELEON использует подход для моделирования степени взаимосвязанности и близости между каждой парой кластеров, который учитывает внутренние характеристики самих кластеров. Таким образом, он может автоматически адаптироваться к внутренним характеристикам объединяемых кластеров.

CHAMELEON находит кластеры в наборе данных с помощью трехфазного алгоритма. На первой фазе происходит построение графа, путём добавления рёбер по принципу k ближайших соседей. На второй фазе CHAMELEON группирует полученные элементы в множество относительно небольших подграфов. Во время третьей фазы применяется агломеративный иерархический алгоритм кластеризации, с помощью которого находятся естесственные кластеры путем многократного объединения подграфов, полученных на прошлом этапе.

[[File:Chameleon.png|1000px|thumb|center|Рисунок 1. Общая структура алгоритма CHAMELEON]]

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

''Исходные данные'':

* Множество из n точек <math>V= {v_{ij}}</math> в метрическом пространстве, которое задано симметрической матрицей расстояний <math>A</math> размера <math>n\times n</math>.
* <math>k</math> - количество ближайших соседей для вершин, <math>k \in N, k \leq n</math>.
* <math>l</math> - наименьшее число вершин, которое может содержать наибольший подграф на 2-м этапе, <math>l \in N, l \leq n</math>.

''Обозначения'':

* <math>G = (V, E)</math> - граф, полученный путём соединения каждой точки с её <math>k</math> ближайшими соседями.

* <math>K= \{K_{i}\}</math> - разбиение множества <math>V</math> на набор попарно непересекающихся связных подмножеств, полученное в результате выполнения второй фазы алгоритма.

* <math>G_{2} = (K, E_{2})</math> - взвешенный граф, вершинами которого являются получившиеся подграфы, а ребрами - количество ребер исходного графа, соединяющих соответствующие подграфы.

* <math>C = \{C_{i}\}</math> - итоговое разбиение множества вершин графа <math>G_{2}</math> на набор кластеров.

''Вспомогательные понятия''

*<math>EC_{(C_{i},C_{j})}</math> - абсолютная взаимная связность пары кластеров <math>C_{i}, C{j}</math>. Определяется как сумма весов ребер, соединяющих вершины, принадлежащие <math>C{i}</math> c вершинами из <math>C{j}</math>. Внутренняя связность <math>EC_{(C_{i},C_{i})}</math> вычисляется как сумма ребер, входящих в разделитель, разбивающий <math>C{i}</math> на два равных подграфа.

*<math>RI_{(C_{i},C_{j})} = \frac{|EC_{(C_{i},C_{j})}|}{(|EC_{C_{i}}|+|EC_{C_{j}}|)/2}</math> - относительная взаимная связность пары кластеров <math>C_{i}, C{j}</math>

*<math>S_{EC_{(C_{i},C_{j})}}</math> - абсолютное взаимное сходство пары кластеров <math>C_{i}, C{j}</math>. Подсчитывается как среднее сходство между соединенными вершинами, принадлежащими <math>C{i}</math> и <math>C{j}</math> соответственно. Соединения обусловлены разбиением общего графа, полученного на первом этапе алгоритма.

*<math> RC_{(C_{i},C_{j})}= \frac{S_{EC_{(C_{i},C_{j})}}}{\frac{|C_{i}|}{|C_{i}+C_{j}|}*S_{EC_{(C_{i})}}+\frac{|C_{i}|}{|C_{i}+C_{j}|}*S_{EC_{(C_{j})}}}</math> - относительное взаимное сходство пары кластеров <math>C_{i}, C{j}</math>. Определяется как абсолютное сходство между этой парой кластеров, нормализованное с учетом их внутреннего сходства<ref>http://studopedia.ru/7_41934_algoritm-dinamicheskoy-ierarhicheskoy-klasterizatsii-CHAMELEON.html</ref>.

'''Первый этап'''

На первом этапе, согласно графо-ориентированному подходу, происходит построение графа <math>G = (V, E)</math> на матрице сходства объектов по принципу k ближайших соседей. Две вершины такого графа соединяет ребро, если объект, соответствующий любой из этих вершин попадает в число k наиболее близких объектов для объекта, соответствующего другой вершине из данной пары.
[[Файл:Снимок chameleon 2.png|2000px|thumb|Рисунок 2. Объекты в пространстве - слева, граф по принципу 1-го ближайшего соседа - по центру, граф по принципу 3-х ближайших соседей - справа ]]

'''Второй этап'''

Алгоритм разделяет полученный граф на множество сравнительно малых подграфов <math>K= \{K_{i}\}</math>. Разделение происходит последовательно. На каждом шаге выбирается подграф, содержащий наибольшее число вершин. Этот граф разделяется на два подграфа так, что разделитель ребер графа минимален и каждый из получаемых подграфов содержит не менее 25 % вершин исходного графа. Процесс разделения останавливается, когда наибольший подграф содержит меньше некоторого заданного числа вершин. Обычно величина этого параметра задается равной значению от 1 до 5 % от числа объектов. Полученное множество связных графов считается множеством начальных кластеров, на котором требуется провести последовательное иерархическое объединение.

'''Третий этап'''

Третий этап заключается в итеративном преобразовании множества подграфов <math>K= \{K_{i}\}</math> в множество кластеров <math>C = \{C_{i}\}</math>. Алгоритм осуществляет агломеративную иерархическую кластеризацию на основании показателей <math>EC_{(C_{i},C_{j})}</math>, <math>S_{EC_{(C_{i},C_{j})}}</math>, <math>RI_{(C_{i},C_{j})} </math>, <math> RC_{(C_{i},C_{j})}</math>. Существует две стратегии анализа показателей сходства. Первая подразумевает наличие некоторых пороговых значений <math>T_{RI}</math> и <math>T_{RC}</math>. В соответствии с этой стратегией, алгоритм для каждого кластера <math>C_{i}</math> проверяет, отвечают ли смежные (наиболее близкие) ему кластеры условиям:

*<math>RI_{(C_{i},C_{j})} \geqslant T_{RI}</math>

*<math>RC_{(C_{i},C_{j})} \geqslant T_{RC}</math>

Если более одного смежного кластера отвечает этим условиям, то алгоритм выбирает для объединения наиболее связный кластер (граф), то есть такой кластер <math>C_{j}</math>, с которым у кластера <math>C_{i}</math> получается наибольшая абсолютная взаимная связность. По завершению прохода по всем кластерам, созданные таким образом пары объединяются. Параметры <math>T_{RI}</math> и <math>T_{RC}</math> могут использоваться для изменения характеристик получаемых кластеров.

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

<math>RI_{(C_{i},C_{j})}*RC_{(C_{i},C_{j})}^\alpha</math>,

где <math>\alpha</math> выбирается пользователем. Если <math>\alpha > 1 </math>, то алгоритм придает большее значение относительному взаимному сходству, а если <math>\alpha < 1 </math>, то большее значение имеет относительная взаимная связность.

''Вычисляемые данные'':

<math>U = (u_1, u_2, ..., u_n)</math> - n-мерный вектор, где <math>u_i \in N_{[C]}</math> - порядковый номер кластера, к которому принадлежит вершина i исходного множества V.

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

Алгоритм имеет три вычислительных ядра, по одному на каждый этап.

На первом этапе вычислительным ядром является процесс нахождения <math>k</math> ближайших соседей для каждой вершины, который заключается в анализе матрицы расстояний.

На втором этапе вычислительным ядром является процесс поиска подходящего разбиения очередного подграфа на два графа с минимизацией разделителя ребер графа.

На третьем этапе вычислительным ядром является расчет величин <math>EC_{(C_{i},C_{j})}</math>, <math>S_{EC_{(C_{i},C_{j})}}</math>, <math>RI_{(C_{i},C_{j})} </math>, <math> RC_{(C_{i},C_{j})}</math> для каждой пары смежных кластеров.

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

Как уже рассказывалось ранее, алгоритм включает в себя три основных этапа, каждый из которых, по сути, является отдельным алгоритмом. Этапы выполняются последовательно относительно друг друга.

Макрооперация на первом этапе - процедура нахождения <math>k</math> ближайших соседей, на втором - процедура разбиения наибольшего подграфа на два графа, на третьем - процедура вычисления показателей сходства, на основе которых принимается решение о слиянии подграфов в кластер.

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

'''Первый этап'''
<source lang="cpp">
int n; //количество вершин
int k; //количество соседей
int A[n][n] //матрица расстояний
int D[k] //массив вершин-соседей
int E[n][n] //матрица ребер графа <math>G_{2} = (K, E_{2})</math>
for i=1 to n-1 do
{
for j=i+1 to n do
{
//заполняем массив вершин-соседей вставляя новые вершины, если они ближе, чем самая далекая из массива.
}
for j=0 to k do
{
//для каждой вершины соседа заполняем соответствующую ячейку из матрицы E[n][n] единицей
}

}
</source>

'''Второй этап'''

1. Все связные подграфы в отсортированном порядке помещаются в список;
2. Берем наибольший элемент списка, вычисляем количество его вершин. Если число вершин > l, то идем в пункт 3. Иначе в пункт 5;
3. Разбиваем подграф на два подграфа таким образом, чтобы разделитель ребер графа был минимален и каждый из получаемых подграфов содержал не менее 25 % вершин исходного графа;
4. Добавляем полученные элементы в список подграфов таким образом, чтобы список оставался отсортированным. Идем в пункт 2;
5. Нашли искомое множество подграфов math>K = \{K_{i}\}</math>;
6. Создаем и заполняем матрицу матрицу расстояний для графа <math>G_{2} = (K, E_{2})</math>. Получаем искомый набор рёбер <math>E_{2}</math>.

'''Третий этап'''

1. Заводим два массива: а) массив кластеров C, полученных на предыдущем этапе, б) массив объединений кластеров F, которые мы будем получать на этом этапе;
2. Берем следующий кластер <math>C_{i}</math> (на первом шаге - первый). Если все кластеры просмотрены, идем в пункт 6;
3. Берем следующий кластер <math>C_{j}, i<>j</math>. Если все кластеры просмотрены, то идем в пункт 2;
4. Проверяем смежность <math>C_{i}</math> и <math>C_{j}</math>. Если не смежны, то возвращаемся в пункт 3. Если смежны, идем в пункт 5;
5. Рассчитываем показатели <math>RI_{(C_{i},C_{j})}</math> и <math> RC_{(C_{i},C_{j})}</math>. Проверяем, удовлетворяют ли найденные значения условиям:
*<math>RI_{(C_{i},C_{j})} \geqslant T_{RI}</math>
*<math>RC_{(C_{i},C_{j})} \geqslant T_{RC}</math>
Если нет, то идем в пункт 3. Иначе если смежность пары кластеров выше, чем у предыдущих найденных, то <math>F_{i}=j</math>. Идем в пункт 3;
6. Если в списке F есть хотя бы одна пара кластеров для слияния, то выполняем слияние, обновляем массив кластеров и массив объединений кластеров. Идем в пункт 2.

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

1) Для построения графа на основе метода k ближайших соседей для n вершин требуется <math>O(n log(n))</math> операций <ref>J.H. Friedman, J.L. Bentley, and R.A. Finkel. An algorithm for ﬁnding best matches in logarithmic expected time. ACM Transactions on Mathematical Software, 3:209–226, 1977.</ref>; для наборов данных большой размерности эта величина составляет <math>O(n^2)</math> операций <ref>S. Berchtold, C. Bohm, D. Keim, and H.-P. Kriegel. Cost model for nearest neighbor search in high dimensional data space. In Proc. of Symposium on Principles of Database Systems, Tucson, Arizona, 1997.</ref>;

2) Для выделения множества сравнительно малых связных подграфов требуется <math>nm</math> операций, где <math>m</math> - количество подграфов, полученных на втором этапе алгоритма;

3) Формирование набора кластеров, на основе множества подграфов, полученных на предыдущем этапе, требует <math>m^2log(m)</math> операций.

Итого, для n вершин получаем последовательную сложность <math>O(n log(n)+nm+m^2log(m))</math>.

== Информационный граф ==
[[File:СК.png]]

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

Первый этап работы алгоритма можно распределить между <math>n</math> процессами. На вход каждому процессу подается своя вершина, далее происходит процедура поиска <math>k</math> ближайших соседей. Параллельная сложность составляет <math>O(n)</math>.

Второй и третий этапы можно распараллелить частично.

Второй этап распараллеливается путем подачи на вход свободному процессу очередного подграфа для разделения. Число итераций оценивается в <math>O(n log(n))</math>.

Третий этап делится на расчет показателей схожести и соединение подграфов в кластеры. Процесс расчета показателей можно распараллелить, подавая каждому процессу на вход пару подграфов. Сложность этого процесса оценивается как <math>m log(m)</math>. Соединение подграфов в кластеры выполняется последовательно, сложность процесса составляет <math>m^2 log(m)</math>

Таким образом получаем общую параллельную сложность алгоритма: <math>O(n+ n log(n) + m^2 log (m) + m log(m))</math>

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

1. Симметрическая матрица <math>A</math> расстояний между элементами данных размера <math>n\times n</math> с нулями на главной диагонали (<math>a_{ii}= 0, i = 1, \ldots, N</math>).

2. <math>k</math> - количество ближайших соседей для вершин (рекомендуемое значение <math>k</math> от 5 до 20 в зависимости от количества анализируемых объектов).

3. <math>l</math> - наименьшее число вершин, которое может содержать наибольший подкластер на 2-м этапе . Величина этого параметра варьируется от 1 до 5 % от общего числа объектов.

'''Объём входных данных'''

<math>\frac{n (n - 1)}{2}</math> (в силу симметричности и нулевой главной диагонали достаточно хранить только над/поддиагональные элементы).

'''Выходные данные'''

Вектор из <math>n</math> чисел <math>u_{1}, u_{2}, \ldots, u_{N}</math>, где <math>u_{i}</math> - целое число, соответствующее кластеру <math>i</math>-го объекта.

'''Объём выходных данных'''

<math>n</math>

== Свойства алгоритма ==
Соотношение последовательной и параллельной сложности на первом этапе является ''линейным'' для больших наборов данных и логарифмическим для n вершин. На втором этапе сложно оценить это соотношение - оно сильно зависит от параметров <math>k</math> и <math>l</math>. На третьем этапе соотношение равно <math>O(1)</math>;

Оценка ''вычислительной мощности'' выглядит следующим образом:

<math>O(1)</math> для 1-го этапа;

<math>O(\frac{nm}{n^2+m^2})</math> для 2-го этапа;

<math>O(\frac{m^2log(m)}{m^2+n})</math> для 3-го этапа;

Алгоритм является ''недетерминированным''. Хотя 1-й этап детерминирован, на 2-ом этапе могут быть найдены различные разбиения на подграфы, что повлияет и на итоговый результат работы алгоритма.

= Программная реализация алгоритма =
== Особенности реализации последовательного алгоритма ==
== Локальность данных и вычислений ==
== Возможные способы и особенности параллельной реализации алгоритма ==
== Масштабируемость алгоритма и его реализации ==
Было проведено исследование эффективности пробной версии параллельной реализации алгоритма<ref>http://research.ijcaonline.org/volume79/number8/pxc3891600.pdf</ref>. Полученные результаты отображены на графике(Рис.3).
По рисунку видно, что с ростом объема данных ускорение и эффективность алгоритма увеличиваются. Однако с ростом числа потоков эффективность уменьшается.

[[File:Масштабирование.jpg|thumb|700px|center|Рис.3 Масштабируемость алгоритма динамической иерархической кластеризации CHAMELEON в зависимости от числа процессоров и размера задачи]]

== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Последовательная реализация алгоритма доступна по ссылке <ref>http://read.pudn.com/downloads36/sourcecode/math/115779/chameleon/chameleon.c__.htm</ref>.

CHAMELEON можно реализовать с использованием графовых библиотек METIS <ref>http://glaros.dtc.umn.edu/gkhome/metis/metis/overview
</ref>, hMETIS <ref>http://glaros.dtc.umn.edu/gkhome/metis/hmetis/overview</ref> и RANN <ref>https://cran.r-project.org/web/packages/RANN/index.html</ref>.

Существует исследование, связанное с реализацией CHAMELEON посредством технологии OpenMP, оно было рассмотрено в пункте 2.4.

Параллельных реализаций алгоритма CHAMELEON не найдено.

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

Участник:ЕкатеринаКозырева/Алгоритм динамической иерархической кластеризации CHAMELEON

2016-12-05T12:48:31Z

ЕкатеринаКозырева: /* Масштабируемость алгоритма и его реализации */

{{Assignment|Kronberg}}
{{algorithm
| name = Алгоритм динамической иерархической кластеризации CHAMELEON
| serial_complexity = <math>O(nm + n log n + m^2 log m)</math>
| input_data = <math>\frac{n (n - 1)}{2}</math>
| output_data = <math>n</math>
| pf_height = <math>O(n+ n log(n) + m^2 log (m) + m log(m))</math>
| pf_width = <math>O(n)</math>
}}

Автор описания [[Участник:ЕкатеринаКозырева|Е.А.Козырева]]
= Свойства и структура алгоритмов =

== Общее описание алгоритма ==
Алгоритм CHAMELEON был предложен в 1999 году тремя учеными из университета Миннесоты – George Karypis, Eui-Hong (Sam) Han и Vipin Kumar<ref>George Karypis, Eui-Hong (Sam) Han и Vipin Kumar, «Chameleon: Hierarchical Clustering Using Dynamic Modeling», 1999.</ref>.

Предназначен для решения задач кластеризации. Кластеризация (или кластерный анализ) — это задача разбиения множества объектов на группы, называемые кластерами. Внутри каждой группы должны оказаться «похожие» объекты, а объекты разных группы должны быть как можно более отличны.

CHAMELEON - это агломеративный иерархический алгоритм кластеризации, ключевой особенностью которого является то, что он учитывает и взаимную связность, и сходство при определении наиболее похожей пары подкластеров, основываясь на динамической модели. Это означает, что в процессе кластеризации два кластера объединяются, только если их относительная взаимная связность и относительное взаимное сходство являются высокими по отношению к внутренней взаимосвязанности кластеров и близости элементов внутри кластеров. Кроме того, CHAMELEON использует подход для моделирования степени взаимосвязанности и близости между каждой парой кластеров, который учитывает внутренние характеристики самих кластеров. Таким образом, он может автоматически адаптироваться к внутренним характеристикам объединяемых кластеров.

CHAMELEON находит кластеры в наборе данных с помощью трехфазного алгоритма. На первой фазе происходит построение графа, путём добавления рёбер по принципу k ближайших соседей. На второй фазе CHAMELEON группирует полученные элементы в множество относительно небольших подграфов. Во время третьей фазы применяется агломеративный иерархический алгоритм кластеризации, с помощью которого находятся естесственные кластеры путем многократного объединения подграфов, полученных на прошлом этапе.

[[File:Chameleon.png|1000px|thumb|center|Рисунок 1. Общая структура алгоритма CHAMELEON]]

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

''Исходные данные'':

* Множество из n точек <math>V= {v_{ij}}</math> в метрическом пространстве, которое задано симметрической матрицей расстояний <math>A</math> размера <math>n\times n</math>.
* <math>k</math> - количество ближайших соседей для вершин, <math>k \in N, k \leq n</math>.
* <math>l</math> - наименьшее число вершин, которое может содержать наибольший подграф на 2-м этапе, <math>l \in N, l \leq n</math>.

''Обозначения'':

* <math>G = (V, E)</math> - граф, полученный путём соединения каждой точки с её <math>k</math> ближайшими соседями.

* <math>K= \{K_{i}\}</math> - разбиение множества <math>V</math> на набор попарно непересекающихся связных подмножеств, полученное в результате выполнения второй фазы алгоритма.

* <math>G_{2} = (K, E_{2})</math> - взвешенный граф, вершинами которого являются получившиеся подграфы, а ребрами - количество ребер исходного графа, соединяющих соответствующие подграфы.

* <math>C = \{C_{i}\}</math> - итоговое разбиение множества вершин графа <math>G_{2}</math> на набор кластеров.

''Вспомогательные понятия''

*<math>EC_{(C_{i},C_{j})}</math> - абсолютная взаимная связность пары кластеров <math>C_{i}, C{j}</math>. Определяется как сумма весов ребер, соединяющих вершины, принадлежащие <math>C{i}</math> c вершинами из <math>C{j}</math>. Внутренняя связность <math>EC_{(C_{i},C_{i})}</math> вычисляется как сумма ребер, входящих в разделитель, разбивающий <math>C{i}</math> на два равных подграфа.

*<math>RI_{(C_{i},C_{j})} = \frac{|EC_{(C_{i},C_{j})}|}{(|EC_{C_{i}}|+|EC_{C_{j}}|)/2}</math> - относительная взаимная связность пары кластеров <math>C_{i}, C{j}</math>

*<math>S_{EC_{(C_{i},C_{j})}}</math> - абсолютное взаимное сходство пары кластеров <math>C_{i}, C{j}</math>. Подсчитывается как среднее сходство между соединенными вершинами, принадлежащими <math>C{i}</math> и <math>C{j}</math> соответственно. Соединения обусловлены разбиением общего графа, полученного на первом этапе алгоритма.

*<math> RC_{(C_{i},C_{j})}= \frac{S_{EC_{(C_{i},C_{j})}}}{\frac{|C_{i}|}{|C_{i}+C_{j}|}*S_{EC_{(C_{i})}}+\frac{|C_{i}|}{|C_{i}+C_{j}|}*S_{EC_{(C_{j})}}}</math> - относительное взаимное сходство пары кластеров <math>C_{i}, C{j}</math>. Определяется как абсолютное сходство между этой парой кластеров, нормализованное с учетом их внутреннего сходства<ref>http://studopedia.ru/7_41934_algoritm-dinamicheskoy-ierarhicheskoy-klasterizatsii-CHAMELEON.html</ref>.

'''Первый этап'''

На первом этапе, согласно графо-ориентированному подходу, происходит построение графа <math>G = (V, E)</math> на матрице сходства объектов по принципу k ближайших соседей. Две вершины такого графа соединяет ребро, если объект, соответствующий любой из этих вершин попадает в число k наиболее близких объектов для объекта, соответствующего другой вершине из данной пары.
[[Файл:Снимок chameleon 2.png|2000px|thumb|Рисунок 2. Объекты в пространстве - слева, граф по принципу 1-го ближайшего соседа - по центру, граф по принципу 3-х ближайших соседей - справа ]]

'''Второй этап'''

Алгоритм разделяет полученный граф на множество сравнительно малых подграфов <math>K= \{K_{i}\}</math>. Разделение происходит последовательно. На каждом шаге выбирается подграф, содержащий наибольшее число вершин. Этот граф разделяется на два подграфа так, что разделитель ребер графа минимален и каждый из получаемых подграфов содержит не менее 25 % вершин исходного графа. Процесс разделения останавливается, когда наибольший подграф содержит меньше некоторого заданного числа вершин. Обычно величина этого параметра задается равной значению от 1 до 5 % от числа объектов. Полученное множество связных графов считается множеством начальных кластеров, на котором требуется провести последовательное иерархическое объединение.

'''Третий этап'''

Третий этап заключается в итеративном преобразовании множества подграфов <math>K= \{K_{i}\}</math> в множество кластеров <math>C = \{C_{i}\}</math>. Алгоритм осуществляет агломеративную иерархическую кластеризацию на основании показателей <math>EC_{(C_{i},C_{j})}</math>, <math>S_{EC_{(C_{i},C_{j})}}</math>, <math>RI_{(C_{i},C_{j})} </math>, <math> RC_{(C_{i},C_{j})}</math>. Существует две стратегии анализа показателей сходства. Первая подразумевает наличие некоторых пороговых значений <math>T_{RI}</math> и <math>T_{RC}</math>. В соответствии с этой стратегией, алгоритм для каждого кластера <math>C_{i}</math> проверяет, отвечают ли смежные (наиболее близкие) ему кластеры условиям:

*<math>RI_{(C_{i},C_{j})} \geqslant T_{RI}</math>

*<math>RC_{(C_{i},C_{j})} \geqslant T_{RC}</math>

Если более одного смежного кластера отвечает этим условиям, то алгоритм выбирает для объединения наиболее связный кластер (граф), то есть такой кластер <math>C_{j}</math>, с которым у кластера <math>C_{i}</math> получается наибольшая абсолютная взаимная связность. По завершению прохода по всем кластерам, созданные таким образом пары объединяются. Параметры <math>T_{RI}</math> и <math>T_{RC}</math> могут использоваться для изменения характеристик получаемых кластеров.

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

<math>RI_{(C_{i},C_{j})}*RC_{(C_{i},C_{j})}^\alpha</math>,

где <math>\alpha</math> выбирается пользователем. Если <math>\alpha > 1 </math>, то алгоритм придает большее значение относительному взаимному сходству, а если <math>\alpha < 1 </math>, то большее значение имеет относительная взаимная связность.

''Вычисляемые данные'':

<math>U = (u_1, u_2, ..., u_n)</math> - n-мерный вектор, где <math>u_i \in N_{[C]}</math> - порядковый номер кластера, к которому принадлежит вершина i исходного множества V.

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

Алгоритм имеет три вычислительных ядра, по одному на каждый этап.

На первом этапе вычислительным ядром является процесс нахождения <math>k</math> ближайших соседей для каждой вершины, который заключается в анализе матрицы расстояний.

На втором этапе вычислительным ядром является процесс поиска подходящего разбиения очередного подграфа на два графа с минимизацией разделителя ребер графа.

На третьем этапе вычислительным ядром является расчет величин <math>EC_{(C_{i},C_{j})}</math>, <math>S_{EC_{(C_{i},C_{j})}}</math>, <math>RI_{(C_{i},C_{j})} </math>, <math> RC_{(C_{i},C_{j})}</math> для каждой пары смежных кластеров.

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

Как уже рассказывалось ранее, алгоритм включает в себя три основных этапа, каждый из которых, по сути, является отдельным алгоритмом. Этапы выполняются последовательно относительно друг друга.

Макрооперация на первом этапе - процедура нахождения <math>k</math> ближайших соседей, на втором - процедура разбиения наибольшего подграфа на два графа, на третьем - процедура вычисления показателей сходства, на основе которых принимается решение о слиянии подграфов в кластер.

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

'''Первый этап'''
<source lang="cpp">
int n; //количество вершин
int k; //количество соседей
int A[n][n] //матрица расстояний
int D[k] //массив вершин-соседей
int E[n][n] //матрица ребер графа <math>G_{2} = (K, E_{2})</math>
for i=1 to n-1 do
{
for j=i+1 to n do
{
//заполняем массив вершин-соседей вставляя новые вершины, если они ближе, чем самая далекая из массива.
}
for j=0 to k do
{
//для каждой вершины соседа заполняем соответствующую ячейку из матрицы E[n][n] единицей
}

}
</source>

'''Второй этап'''

1. Все связные подграфы в отсортированном порядке помещаются в список;
2. Берем наибольший элемент списка, вычисляем количество его вершин. Если число вершин > l, то идем в пункт 3. Иначе в пункт 5;
3. Разбиваем подграф на два подграфа таким образом, чтобы разделитель ребер графа был минимален и каждый из получаемых подграфов содержал не менее 25 % вершин исходного графа;
4. Добавляем полученные элементы в список подграфов таким образом, чтобы список оставался отсортированным. Идем в пункт 2;
5. Нашли искомое множество подграфов math>K = \{K_{i}\}</math>;
6. Создаем и заполняем матрицу матрицу расстояний для графа <math>G_{2} = (K, E_{2})</math>. Получаем искомый набор рёбер <math>E_{2}</math>.

'''Третий этап'''

1. Заводим два массива: а) массив кластеров C, полученных на предыдущем этапе, б) массив объединений кластеров F, которые мы будем получать на этом этапе;
2. Берем следующий кластер <math>C_{i}</math> (на первом шаге - первый). Если все кластеры просмотрены, идем в пункт 6;
3. Берем следующий кластер <math>C_{j}, i<>j</math>. Если все кластеры просмотрены, то идем в пункт 2;
4. Проверяем смежность <math>C_{i}</math> и <math>C_{j}</math>. Если не смежны, то возвращаемся в пункт 3. Если смежны, идем в пункт 5;
5. Рассчитываем показатели <math>RI_{(C_{i},C_{j})}</math> и <math> RC_{(C_{i},C_{j})}</math>. Проверяем, удовлетворяют ли найденные значения условиям:
*<math>RI_{(C_{i},C_{j})} \geqslant T_{RI}</math>
*<math>RC_{(C_{i},C_{j})} \geqslant T_{RC}</math>
Если нет, то идем в пункт 3. Иначе если смежность пары кластеров выше, чем у предыдущих найденных, то <math>F_{i}=j</math>. Идем в пункт 3;
6. Если в списке F есть хотя бы одна пара кластеров для слияния, то выполняем слияние, обновляем массив кластеров и массив объединений кластеров. Идем в пункт 2.

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

1) Для построения графа на основе метода k ближайших соседей для n вершин требуется <math>O(n log(n))</math> операций <ref>J.H. Friedman, J.L. Bentley, and R.A. Finkel. An algorithm for ﬁnding best matches in logarithmic expected time. ACM Transactions on Mathematical Software, 3:209–226, 1977.</ref>; для наборов данных большой размерности эта величина составляет <math>O(n^2)</math> операций <ref>S. Berchtold, C. Bohm, D. Keim, and H.-P. Kriegel. Cost model for nearest neighbor search in high dimensional data space. In Proc. of Symposium on Principles of Database Systems, Tucson, Arizona, 1997.</ref>;

2) Для выделения множества сравнительно малых связных подграфов требуется <math>nm</math> операций, где <math>m</math> - количество подграфов, полученных на втором этапе алгоритма;

3) Формирование набора кластеров, на основе множества подграфов, полученных на предыдущем этапе, требует <math>m^2log(m)</math> операций.

Итого, для n вершин получаем последовательную сложность <math>O(n log(n)+nm+m^2log(m))</math>.

== Информационный граф ==
[[File:СК.png]]

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

Первый этап работы алгоритма можно распределить между <math>n</math> процессами. На вход каждому процессу подается своя вершина, далее происходит процедура поиска <math>k</math> ближайших соседей. Параллельная сложность составляет <math>O(n)</math>.

Второй и третий этапы можно распараллелить частично.

Второй этап распараллеливается путем подачи на вход свободному процессу очередного подграфа для разделения. Число итераций оценивается в <math>O(n log(n))</math>.

Третий этап делится на расчет показателей схожести и соединение подграфов в кластеры. Процесс расчета показателей можно распараллелить, подавая каждому процессу на вход пару подграфов. Сложность этого процесса оценивается как <math>m log(m)</math>. Соединение подграфов в кластеры выполняется последовательно, сложность процесса составляет <math>m^2 log(m)</math>

Таким образом получаем общую параллельную сложность алгоритма: <math>O(n+ n log(n) + m^2 log (m) + m log(m))</math>

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

1. Симметрическая матрица <math>A</math> расстояний между элементами данных размера <math>n\times n</math> с нулями на главной диагонали (<math>a_{ii}= 0, i = 1, \ldots, N</math>).

2. <math>k</math> - количество ближайших соседей для вершин (рекомендуемое значение <math>k</math> от 5 до 20 в зависимости от количества анализируемых объектов).

3. <math>l</math> - наименьшее число вершин, которое может содержать наибольший подкластер на 2-м этапе . Величина этого параметра варьируется от 1 до 5 % от общего числа объектов.

'''Объём входных данных'''

<math>\frac{n (n - 1)}{2}</math> (в силу симметричности и нулевой главной диагонали достаточно хранить только над/поддиагональные элементы).

'''Выходные данные'''

Вектор из <math>n</math> чисел <math>u_{1}, u_{2}, \ldots, u_{N}</math>, где <math>u_{i}</math> - целое число, соответствующее кластеру <math>i</math>-го объекта.

'''Объём выходных данных'''

<math>n</math>

== Свойства алгоритма ==
Соотношение последовательной и параллельной сложности на первом этапе является ''линейным'' для больших наборов данных и логарифмическим для n вершин. На втором этапе сложно оценить это соотношение - оно сильно зависит от параметров <math>k</math> и <math>l</math>. На третьем этапе соотношение равно <math>O(1)</math>;

Оценка ''вычислительной мощности'' выглядит следующим образом:

<math>O(1)</math> для 1-го этапа;

<math>O(\frac{nm}{n^2+m^2})</math> для 2-го этапа;

<math>O(\frac{m^2log(m)}{m^2+n})</math> для 3-го этапа;

Алгоритм является ''недетерминированным''. Хотя 1-й этап детерминирован, на 2-ом этапе могут быть найдены различные разбиения на подграфы, что повлияет и на итоговый результат работы алгоритма.

= Программная реализация алгоритма =
== Особенности реализации последовательного алгоритма ==
== Локальность данных и вычислений ==
== Возможные способы и особенности параллельной реализации алгоритма ==
== Масштабируемость алгоритма и его реализации ==
Было проведено исследование эффективности пробной версии параллельной реализации алгоритма<ref>http://research.ijcaonline.org/volume79/number8/pxc3891600.pdf</ref>. Полученные результаты отображены на графике(Рис.3).
По рисунку видно, что с ростом объема данных ускорение и эффективность алгоритма увеличиваются. Однако с ростом числа потоков эффективность уменьшается.

[[File:Масштабирование.jpg|thumb|700px|center|Рис.3 Масштабируемость алгоритма динамической иерархической кластеризации CHAMELEON в зависимости от числа процессоров и размера задачи]]

== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Последовательная реализация алгоритма доступна по ссылке <ref>http://read.pudn.com/downloads36/sourcecode/math/115779/chameleon/chameleon.c__.htm</ref>.

CHAMELEON можно реализовать с использованием графовых библиотек METIS <ref>http://glaros.dtc.umn.edu/gkhome/metis/metis/overview
</ref>, hMETIS <ref>http://glaros.dtc.umn.edu/gkhome/metis/hmetis/overview</ref> и RANN <ref>https://cran.r-project.org/web/packages/RANN/index.html</ref>.

Существует исследование, связанное с реализацией CHAMELEON посредством технологии OpenMP, оно было рассмотрено в пункте 2.4.

Параллельных реализаций алгоритма CHAMELEON не найдено.

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

Участник:ЕкатеринаКозырева/Алгоритм динамической иерархической кластеризации CHAMELEON

2016-12-05T09:29:44Z

ЕкатеринаКозырева: /* Масштабируемость алгоритма и его реализации */

{{Assignment|Kronberg}}
{{algorithm
| name = Алгоритм динамической иерархической кластеризации CHAMELEON
| serial_complexity = <math>O(nm + n log n + m^2 log m)</math>
| input_data = <math>\frac{n (n - 1)}{2}</math>
| output_data = <math>n</math>
| pf_height = <math>O(n+ n log(n) + m^2 log (m) + m log(m))</math>
| pf_width = <math>O(n)</math>
}}

Автор описания [[Участник:ЕкатеринаКозырева|Е.А.Козырева]]
= Свойства и структура алгоритмов =

== Общее описание алгоритма ==
Алгоритм CHAMELEON был предложен в 1999 году тремя учеными из университета Миннесоты – George Karypis, Eui-Hong (Sam) Han и Vipin Kumar<ref>George Karypis, Eui-Hong (Sam) Han и Vipin Kumar, «Chameleon: Hierarchical Clustering Using Dynamic Modeling», 1999.</ref>.

Предназначен для решения задач кластеризации. Кластеризация (или кластерный анализ) — это задача разбиения множества объектов на группы, называемые кластерами. Внутри каждой группы должны оказаться «похожие» объекты, а объекты разных группы должны быть как можно более отличны.

CHAMELEON - это агломеративный иерархический алгоритм кластеризации, ключевой особенностью которого является то, что он учитывает и взаимную связность, и сходство при определении наиболее похожей пары подкластеров, основываясь на динамической модели. Это означает, что в процессе кластеризации два кластера объединяются, только если их относительная взаимная связность и относительное взаимное сходство являются высокими по отношению к внутренней взаимосвязанности кластеров и близости элементов внутри кластеров. Кроме того, CHAMELEON использует подход для моделирования степени взаимосвязанности и близости между каждой парой кластеров, который учитывает внутренние характеристики самих кластеров. Таким образом, он может автоматически адаптироваться к внутренним характеристикам объединяемых кластеров.

CHAMELEON находит кластеры в наборе данных с помощью трехфазного алгоритма. На первой фазе происходит построение графа, путём добавления рёбер по принципу k ближайших соседей. На второй фазе CHAMELEON группирует полученные элементы в множество относительно небольших подграфов. Во время третьей фазы применяется агломеративный иерархический алгоритм кластеризации, с помощью которого находятся естесственные кластеры путем многократного объединения подграфов, полученных на прошлом этапе.

[[File:Chameleon.png|1000px|thumb|center|Рисунок 1. Общая структура алгоритма CHAMELEON]]

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

''Исходные данные'':

* Множество из n точек <math>V= {v_{ij}}</math> в метрическом пространстве, которое задано симметрической матрицей расстояний <math>A</math> размера <math>n\times n</math>.
* <math>k</math> - количество ближайших соседей для вершин, <math>k \in N, k \leq n</math>.
* <math>l</math> - наименьшее число вершин, которое может содержать наибольший подграф на 2-м этапе, <math>l \in N, l \leq n</math>.

''Обозначения'':

* <math>G = (V, E)</math> - граф, полученный путём соединения каждой точки с её <math>k</math> ближайшими соседями.

* <math>K= \{K_{i}\}</math> - разбиение множества <math>V</math> на набор попарно непересекающихся связных подмножеств, полученное в результате выполнения второй фазы алгоритма.

* <math>G_{2} = (K, E_{2})</math> - взвешенный граф, вершинами которого являются получившиеся подграфы, а ребрами - количество ребер исходного графа, соединяющих соответствующие подграфы.

* <math>C = \{C_{i}\}</math> - итоговое разбиение множества вершин графа <math>G_{2}</math> на набор кластеров.

''Вспомогательные понятия''

*<math>EC_{(C_{i},C_{j})}</math> - абсолютная взаимная связность пары кластеров <math>C_{i}, C{j}</math>. Определяется как сумма весов ребер, соединяющих вершины, принадлежащие <math>C{i}</math> c вершинами из <math>C{j}</math>. Внутренняя связность <math>EC_{(C_{i},C_{i})}</math> вычисляется как сумма ребер, входящих в разделитель, разбивающий <math>C{i}</math> на два равных подграфа.

*<math>RI_{(C_{i},C_{j})} = \frac{|EC_{(C_{i},C_{j})}|}{(|EC_{C_{i}}|+|EC_{C_{j}}|)/2}</math> - относительная взаимная связность пары кластеров <math>C_{i}, C{j}</math>

*<math>S_{EC_{(C_{i},C_{j})}}</math> - абсолютное взаимное сходство пары кластеров <math>C_{i}, C{j}</math>. Подсчитывается как среднее сходство между соединенными вершинами, принадлежащими <math>C{i}</math> и <math>C{j}</math> соответственно. Соединения обусловлены разбиением общего графа, полученного на первом этапе алгоритма.

*<math> RC_{(C_{i},C_{j})}= \frac{S_{EC_{(C_{i},C_{j})}}}{\frac{|C_{i}|}{|C_{i}+C_{j}|}*S_{EC_{(C_{i})}}+\frac{|C_{i}|}{|C_{i}+C_{j}|}*S_{EC_{(C_{j})}}}</math> - относительное взаимное сходство пары кластеров <math>C_{i}, C{j}</math>. Определяется как абсолютное сходство между этой парой кластеров, нормализованное с учетом их внутреннего сходства<ref>http://studopedia.ru/7_41934_algoritm-dinamicheskoy-ierarhicheskoy-klasterizatsii-CHAMELEON.html</ref>.

'''Первый этап'''

На первом этапе, согласно графо-ориентированному подходу, происходит построение графа <math>G = (V, E)</math> на матрице сходства объектов по принципу k ближайших соседей. Две вершины такого графа соединяет ребро, если объект, соответствующий любой из этих вершин попадает в число k наиболее близких объектов для объекта, соответствующего другой вершине из данной пары.
[[Файл:Снимок chameleon 2.png|2000px|thumb|Рисунок 2. Объекты в пространстве - слева, граф по принципу 1-го ближайшего соседа - по центру, граф по принципу 3-х ближайших соседей - справа ]]

'''Второй этап'''

Алгоритм разделяет полученный граф на множество сравнительно малых подграфов <math>K= \{K_{i}\}</math>. Разделение происходит последовательно. На каждом шаге выбирается подграф, содержащий наибольшее число вершин. Этот граф разделяется на два подграфа так, что разделитель ребер графа минимален и каждый из получаемых подграфов содержит не менее 25 % вершин исходного графа. Процесс разделения останавливается, когда наибольший подграф содержит меньше некоторого заданного числа вершин. Обычно величина этого параметра задается равной значению от 1 до 5 % от числа объектов. Полученное множество связных графов считается множеством начальных кластеров, на котором требуется провести последовательное иерархическое объединение.

'''Третий этап'''

Третий этап заключается в итеративном преобразовании множества подграфов <math>K= \{K_{i}\}</math> в множество кластеров <math>C = \{C_{i}\}</math>. Алгоритм осуществляет агломеративную иерархическую кластеризацию на основании показателей <math>EC_{(C_{i},C_{j})}</math>, <math>S_{EC_{(C_{i},C_{j})}}</math>, <math>RI_{(C_{i},C_{j})} </math>, <math> RC_{(C_{i},C_{j})}</math>. Существует две стратегии анализа показателей сходства. Первая подразумевает наличие некоторых пороговых значений <math>T_{RI}</math> и <math>T_{RC}</math>. В соответствии с этой стратегией, алгоритм для каждого кластера <math>C_{i}</math> проверяет, отвечают ли смежные (наиболее близкие) ему кластеры условиям:

*<math>RI_{(C_{i},C_{j})} \geqslant T_{RI}</math>

*<math>RC_{(C_{i},C_{j})} \geqslant T_{RC}</math>

Если более одного смежного кластера отвечает этим условиям, то алгоритм выбирает для объединения наиболее связный кластер (граф), то есть такой кластер <math>C_{j}</math>, с которым у кластера <math>C_{i}</math> получается наибольшая абсолютная взаимная связность. По завершению прохода по всем кластерам, созданные таким образом пары объединяются. Параметры <math>T_{RI}</math> и <math>T_{RC}</math> могут использоваться для изменения характеристик получаемых кластеров.

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

<math>RI_{(C_{i},C_{j})}*RC_{(C_{i},C_{j})}^\alpha</math>,

где <math>\alpha</math> выбирается пользователем. Если <math>\alpha > 1 </math>, то алгоритм придает большее значение относительному взаимному сходству, а если <math>\alpha < 1 </math>, то большее значение имеет относительная взаимная связность.

''Вычисляемые данные'':

<math>U = (u_1, u_2, ..., u_n)</math> - n-мерный вектор, где <math>u_i \in N_{[C]}</math> - порядковый номер кластера, к которому принадлежит вершина i исходного множества V.

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

Алгоритм имеет три вычислительных ядра, по одному на каждый этап.

На первом этапе вычислительным ядром является процесс нахождения <math>k</math> ближайших соседей для каждой вершины, который заключается в анализе матрицы расстояний.

На втором этапе вычислительным ядром является процесс поиска подходящего разбиения очередного подграфа на два графа с минимизацией разделителя ребер графа.

На третьем этапе вычислительным ядром является расчет величин <math>EC_{(C_{i},C_{j})}</math>, <math>S_{EC_{(C_{i},C_{j})}}</math>, <math>RI_{(C_{i},C_{j})} </math>, <math> RC_{(C_{i},C_{j})}</math> для каждой пары смежных кластеров.

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

Как уже рассказывалось ранее, алгоритм включает в себя три основных этапа, каждый из которых, по сути, является отдельным алгоритмом. Этапы выполняются последовательно относительно друг друга.

Макрооперация на первом этапе - процедура нахождения <math>k</math> ближайших соседей, на втором - процедура разбиения наибольшего подграфа на два графа, на третьем - процедура вычисления показателей сходства, на основе которых принимается решение о слиянии подграфов в кластер.

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

'''Первый этап'''
<source lang="cpp">
int n; //количество вершин
int k; //количество соседей
int A[n][n] //матрица расстояний
int D[k] //массив вершин-соседей
int E[n][n] //матрица ребер графа <math>G_{2} = (K, E_{2})</math>
for i=1 to n-1 do
{
for j=i+1 to n do
{
//заполняем массив вершин-соседей вставляя новые вершины, если они ближе, чем самая далекая из массива.
}
for j=0 to k do
{
//для каждой вершины соседа заполняем соответствующую ячейку из матрицы E[n][n] единицей
}

}
</source>

'''Второй этап'''

1. Все связные подграфы в отсортированном порядке помещаются в список;
2. Берем наибольший элемент списка, вычисляем количество его вершин. Если число вершин > l, то идем в пункт 3. Иначе в пункт 5;
3. Разбиваем подграф на два подграфа таким образом, чтобы разделитель ребер графа был минимален и каждый из получаемых подграфов содержал не менее 25 % вершин исходного графа;
4. Добавляем полученные элементы в список подграфов таким образом, чтобы список оставался отсортированным. Идем в пункт 2;
5. Нашли искомое множество подграфов math>K = \{K_{i}\}</math>;
6. Создаем и заполняем матрицу матрицу расстояний для графа <math>G_{2} = (K, E_{2})</math>. Получаем искомый набор рёбер <math>E_{2}</math>.

'''Третий этап'''

1. Заводим два массива: а) массив кластеров C, полученных на предыдущем этапе, б) массив объединений кластеров F, которые мы будем получать на этом этапе;
2. Берем следующий кластер <math>C_{i}</math> (на первом шаге - первый). Если все кластеры просмотрены, идем в пункт 6;
3. Берем следующий кластер <math>C_{j}, i<>j</math>. Если все кластеры просмотрены, то идем в пункт 2;
4. Проверяем смежность <math>C_{i}</math> и <math>C_{j}</math>. Если не смежны, то возвращаемся в пункт 3. Если смежны, идем в пункт 5;
5. Рассчитываем показатели <math>RI_{(C_{i},C_{j})}</math> и <math> RC_{(C_{i},C_{j})}</math>. Проверяем, удовлетворяют ли найденные значения условиям:
*<math>RI_{(C_{i},C_{j})} \geqslant T_{RI}</math>
*<math>RC_{(C_{i},C_{j})} \geqslant T_{RC}</math>
Если нет, то идем в пункт 3. Иначе если смежность пары кластеров выше, чем у предыдущих найденных, то <math>F_{i}=j</math>. Идем в пункт 3;
6. Если в списке F есть хотя бы одна пара кластеров для слияния, то выполняем слияние, обновляем массив кластеров и массив объединений кластеров. Идем в пункт 2.

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

1) Для построения графа на основе метода k ближайших соседей для n вершин требуется <math>O(n log(n))</math> операций <ref>J.H. Friedman, J.L. Bentley, and R.A. Finkel. An algorithm for ﬁnding best matches in logarithmic expected time. ACM Transactions on Mathematical Software, 3:209–226, 1977.</ref>; для наборов данных большой размерности эта величина составляет <math>O(n^2)</math> операций <ref>S. Berchtold, C. Bohm, D. Keim, and H.-P. Kriegel. Cost model for nearest neighbor search in high dimensional data space. In Proc. of Symposium on Principles of Database Systems, Tucson, Arizona, 1997.</ref>;

2) Для выделения множества сравнительно малых связных подграфов требуется <math>nm</math> операций, где <math>m</math> - количество подграфов, полученных на втором этапе алгоритма;

3) Формирование набора кластеров, на основе множества подграфов, полученных на предыдущем этапе, требует <math>m^2log(m)</math> операций.

Итого, для n вершин получаем последовательную сложность <math>O(n log(n)+nm+m^2log(m))</math>.

== Информационный граф ==
[[File:СК.png]]

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

Первый этап работы алгоритма можно распределить между <math>n</math> процессами. На вход каждому процессу подается своя вершина, далее происходит процедура поиска <math>k</math> ближайших соседей. Параллельная сложность составляет <math>O(n)</math>.

Второй и третий этапы можно распараллелить частично.

Второй этап распараллеливается путем подачи на вход свободному процессу очередного подграфа для разделения. Число итераций оценивается в <math>O(n log(n))</math>.

Третий этап делится на расчет показателей схожести и соединение подграфов в кластеры. Процесс расчета показателей можно распараллелить, подавая каждому процессу на вход пару подграфов. Сложность этого процесса оценивается как <math>m log(m)</math>. Соединение подграфов в кластеры выполняется последовательно, сложность процесса составляет <math>m^2 log(m)</math>

Таким образом получаем общую параллельную сложность алгоритма: <math>O(n+ n log(n) + m^2 log (m) + m log(m))</math>

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

1. Симметрическая матрица <math>A</math> расстояний между элементами данных размера <math>n\times n</math> с нулями на главной диагонали (<math>a_{ii}= 0, i = 1, \ldots, N</math>).

2. <math>k</math> - количество ближайших соседей для вершин (рекомендуемое значение <math>k</math> от 5 до 20 в зависимости от количества анализируемых объектов).

3. <math>l</math> - наименьшее число вершин, которое может содержать наибольший подкластер на 2-м этапе . Величина этого параметра варьируется от 1 до 5 % от общего числа объектов.

'''Объём входных данных'''

<math>\frac{n (n - 1)}{2}</math> (в силу симметричности и нулевой главной диагонали достаточно хранить только над/поддиагональные элементы).

'''Выходные данные'''

Вектор из <math>n</math> чисел <math>u_{1}, u_{2}, \ldots, u_{N}</math>, где <math>u_{i}</math> - целое число, соответствующее кластеру <math>i</math>-го объекта.

'''Объём выходных данных'''

<math>n</math>

== Свойства алгоритма ==
Соотношение последовательной и параллельной сложности на первом этапе является ''линейным'' для больших наборов данных и логарифмическим для n вершин. На втором этапе сложно оценить это соотношение - оно сильно зависит от параметров <math>k</math> и <math>l</math>. На третьем этапе соотношение равно <math>O(1)</math>;

Оценка ''вычислительной мощности'' выглядит следующим образом:

<math>O(1)</math> для 1-го этапа;

<math>O(\frac{nm}{n^2+m^2})</math> для 2-го этапа;

<math>O(\frac{m^2log(m)}{m^2+n})</math> для 3-го этапа;

Алгоритм является ''недетерминированным''. Хотя 1-й этап детерминирован, на 2-ом этапе могут быть найдены различные разбиения на подграфы, что повлияет и на итоговый результат работы алгоритма.

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

[[File:Масштабирование.jpg|thumb|700px|center|Рис.3 Масштабируемость алгоритма динамической иерархической кластеризации CHAMELEON в зависимости от числа процессоров и размера задачи]]

== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Последовательная реализация алгоритма доступна по ссылке <ref>http://read.pudn.com/downloads36/sourcecode/math/115779/chameleon/chameleon.c__.htm</ref>.

CHAMELEON можно реализовать с использованием графовых библиотек METIS <ref>http://glaros.dtc.umn.edu/gkhome/metis/metis/overview
</ref>, hMETIS <ref>http://glaros.dtc.umn.edu/gkhome/metis/hmetis/overview</ref> и RANN <ref>https://cran.r-project.org/web/packages/RANN/index.html</ref>.

Существует исследование, связанное с реализацией CHAMELEON посредством технологии OpenMP, оно было рассмотрено в пункте 2.4.

Параллельных реализаций алгоритма CHAMELEON не найдено.

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

Участник:ЕкатеринаКозырева/Алгоритм динамической иерархической кластеризации CHAMELEON

2016-12-05T09:28:00Z

ЕкатеринаКозырева: /* Масштабируемость алгоритма и его реализации */

{{Assignment|Kronberg}}
{{algorithm
| name = Алгоритм динамической иерархической кластеризации CHAMELEON
| serial_complexity = <math>O(nm + n log n + m^2 log m)</math>
| input_data = <math>\frac{n (n - 1)}{2}</math>
| output_data = <math>n</math>
| pf_height = <math>O(n+ n log(n) + m^2 log (m) + m log(m))</math>
| pf_width = <math>O(n)</math>
}}

Автор описания [[Участник:ЕкатеринаКозырева|Е.А.Козырева]]
= Свойства и структура алгоритмов =

== Общее описание алгоритма ==
Алгоритм CHAMELEON был предложен в 1999 году тремя учеными из университета Миннесоты – George Karypis, Eui-Hong (Sam) Han и Vipin Kumar<ref>George Karypis, Eui-Hong (Sam) Han и Vipin Kumar, «Chameleon: Hierarchical Clustering Using Dynamic Modeling», 1999.</ref>.

Предназначен для решения задач кластеризации. Кластеризация (или кластерный анализ) — это задача разбиения множества объектов на группы, называемые кластерами. Внутри каждой группы должны оказаться «похожие» объекты, а объекты разных группы должны быть как можно более отличны.

CHAMELEON - это агломеративный иерархический алгоритм кластеризации, ключевой особенностью которого является то, что он учитывает и взаимную связность, и сходство при определении наиболее похожей пары подкластеров, основываясь на динамической модели. Это означает, что в процессе кластеризации два кластера объединяются, только если их относительная взаимная связность и относительное взаимное сходство являются высокими по отношению к внутренней взаимосвязанности кластеров и близости элементов внутри кластеров. Кроме того, CHAMELEON использует подход для моделирования степени взаимосвязанности и близости между каждой парой кластеров, который учитывает внутренние характеристики самих кластеров. Таким образом, он может автоматически адаптироваться к внутренним характеристикам объединяемых кластеров.

CHAMELEON находит кластеры в наборе данных с помощью трехфазного алгоритма. На первой фазе происходит построение графа, путём добавления рёбер по принципу k ближайших соседей. На второй фазе CHAMELEON группирует полученные элементы в множество относительно небольших подграфов. Во время третьей фазы применяется агломеративный иерархический алгоритм кластеризации, с помощью которого находятся естесственные кластеры путем многократного объединения подграфов, полученных на прошлом этапе.

[[File:Chameleon.png|1000px|thumb|center|Рисунок 1. Общая структура алгоритма CHAMELEON]]

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

''Исходные данные'':

* Множество из n точек <math>V= {v_{ij}}</math> в метрическом пространстве, которое задано симметрической матрицей расстояний <math>A</math> размера <math>n\times n</math>.
* <math>k</math> - количество ближайших соседей для вершин, <math>k \in N, k \leq n</math>.
* <math>l</math> - наименьшее число вершин, которое может содержать наибольший подграф на 2-м этапе, <math>l \in N, l \leq n</math>.

''Обозначения'':

* <math>G = (V, E)</math> - граф, полученный путём соединения каждой точки с её <math>k</math> ближайшими соседями.

* <math>K= \{K_{i}\}</math> - разбиение множества <math>V</math> на набор попарно непересекающихся связных подмножеств, полученное в результате выполнения второй фазы алгоритма.

* <math>G_{2} = (K, E_{2})</math> - взвешенный граф, вершинами которого являются получившиеся подграфы, а ребрами - количество ребер исходного графа, соединяющих соответствующие подграфы.

* <math>C = \{C_{i}\}</math> - итоговое разбиение множества вершин графа <math>G_{2}</math> на набор кластеров.

''Вспомогательные понятия''

*<math>EC_{(C_{i},C_{j})}</math> - абсолютная взаимная связность пары кластеров <math>C_{i}, C{j}</math>. Определяется как сумма весов ребер, соединяющих вершины, принадлежащие <math>C{i}</math> c вершинами из <math>C{j}</math>. Внутренняя связность <math>EC_{(C_{i},C_{i})}</math> вычисляется как сумма ребер, входящих в разделитель, разбивающий <math>C{i}</math> на два равных подграфа.

*<math>RI_{(C_{i},C_{j})} = \frac{|EC_{(C_{i},C_{j})}|}{(|EC_{C_{i}}|+|EC_{C_{j}}|)/2}</math> - относительная взаимная связность пары кластеров <math>C_{i}, C{j}</math>

*<math>S_{EC_{(C_{i},C_{j})}}</math> - абсолютное взаимное сходство пары кластеров <math>C_{i}, C{j}</math>. Подсчитывается как среднее сходство между соединенными вершинами, принадлежащими <math>C{i}</math> и <math>C{j}</math> соответственно. Соединения обусловлены разбиением общего графа, полученного на первом этапе алгоритма.

*<math> RC_{(C_{i},C_{j})}= \frac{S_{EC_{(C_{i},C_{j})}}}{\frac{|C_{i}|}{|C_{i}+C_{j}|}*S_{EC_{(C_{i})}}+\frac{|C_{i}|}{|C_{i}+C_{j}|}*S_{EC_{(C_{j})}}}</math> - относительное взаимное сходство пары кластеров <math>C_{i}, C{j}</math>. Определяется как абсолютное сходство между этой парой кластеров, нормализованное с учетом их внутреннего сходства<ref>http://studopedia.ru/7_41934_algoritm-dinamicheskoy-ierarhicheskoy-klasterizatsii-CHAMELEON.html</ref>.

'''Первый этап'''

На первом этапе, согласно графо-ориентированному подходу, происходит построение графа <math>G = (V, E)</math> на матрице сходства объектов по принципу k ближайших соседей. Две вершины такого графа соединяет ребро, если объект, соответствующий любой из этих вершин попадает в число k наиболее близких объектов для объекта, соответствующего другой вершине из данной пары.
[[Файл:Снимок chameleon 2.png|2000px|thumb|Рисунок 2. Объекты в пространстве - слева, граф по принципу 1-го ближайшего соседа - по центру, граф по принципу 3-х ближайших соседей - справа ]]

'''Второй этап'''

Алгоритм разделяет полученный граф на множество сравнительно малых подграфов <math>K= \{K_{i}\}</math>. Разделение происходит последовательно. На каждом шаге выбирается подграф, содержащий наибольшее число вершин. Этот граф разделяется на два подграфа так, что разделитель ребер графа минимален и каждый из получаемых подграфов содержит не менее 25 % вершин исходного графа. Процесс разделения останавливается, когда наибольший подграф содержит меньше некоторого заданного числа вершин. Обычно величина этого параметра задается равной значению от 1 до 5 % от числа объектов. Полученное множество связных графов считается множеством начальных кластеров, на котором требуется провести последовательное иерархическое объединение.

'''Третий этап'''

Третий этап заключается в итеративном преобразовании множества подграфов <math>K= \{K_{i}\}</math> в множество кластеров <math>C = \{C_{i}\}</math>. Алгоритм осуществляет агломеративную иерархическую кластеризацию на основании показателей <math>EC_{(C_{i},C_{j})}</math>, <math>S_{EC_{(C_{i},C_{j})}}</math>, <math>RI_{(C_{i},C_{j})} </math>, <math> RC_{(C_{i},C_{j})}</math>. Существует две стратегии анализа показателей сходства. Первая подразумевает наличие некоторых пороговых значений <math>T_{RI}</math> и <math>T_{RC}</math>. В соответствии с этой стратегией, алгоритм для каждого кластера <math>C_{i}</math> проверяет, отвечают ли смежные (наиболее близкие) ему кластеры условиям:

*<math>RI_{(C_{i},C_{j})} \geqslant T_{RI}</math>

*<math>RC_{(C_{i},C_{j})} \geqslant T_{RC}</math>

Если более одного смежного кластера отвечает этим условиям, то алгоритм выбирает для объединения наиболее связный кластер (граф), то есть такой кластер <math>C_{j}</math>, с которым у кластера <math>C_{i}</math> получается наибольшая абсолютная взаимная связность. По завершению прохода по всем кластерам, созданные таким образом пары объединяются. Параметры <math>T_{RI}</math> и <math>T_{RC}</math> могут использоваться для изменения характеристик получаемых кластеров.

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

<math>RI_{(C_{i},C_{j})}*RC_{(C_{i},C_{j})}^\alpha</math>,

где <math>\alpha</math> выбирается пользователем. Если <math>\alpha > 1 </math>, то алгоритм придает большее значение относительному взаимному сходству, а если <math>\alpha < 1 </math>, то большее значение имеет относительная взаимная связность.

''Вычисляемые данные'':

<math>U = (u_1, u_2, ..., u_n)</math> - n-мерный вектор, где <math>u_i \in N_{[C]}</math> - порядковый номер кластера, к которому принадлежит вершина i исходного множества V.

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

Алгоритм имеет три вычислительных ядра, по одному на каждый этап.

На первом этапе вычислительным ядром является процесс нахождения <math>k</math> ближайших соседей для каждой вершины, который заключается в анализе матрицы расстояний.

На втором этапе вычислительным ядром является процесс поиска подходящего разбиения очередного подграфа на два графа с минимизацией разделителя ребер графа.

На третьем этапе вычислительным ядром является расчет величин <math>EC_{(C_{i},C_{j})}</math>, <math>S_{EC_{(C_{i},C_{j})}}</math>, <math>RI_{(C_{i},C_{j})} </math>, <math> RC_{(C_{i},C_{j})}</math> для каждой пары смежных кластеров.

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

Как уже рассказывалось ранее, алгоритм включает в себя три основных этапа, каждый из которых, по сути, является отдельным алгоритмом. Этапы выполняются последовательно относительно друг друга.

Макрооперация на первом этапе - процедура нахождения <math>k</math> ближайших соседей, на втором - процедура разбиения наибольшего подграфа на два графа, на третьем - процедура вычисления показателей сходства, на основе которых принимается решение о слиянии подграфов в кластер.

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

'''Первый этап'''
<source lang="cpp">
int n; //количество вершин
int k; //количество соседей
int A[n][n] //матрица расстояний
int D[k] //массив вершин-соседей
int E[n][n] //матрица ребер графа <math>G_{2} = (K, E_{2})</math>
for i=1 to n-1 do
{
for j=i+1 to n do
{
//заполняем массив вершин-соседей вставляя новые вершины, если они ближе, чем самая далекая из массива.
}
for j=0 to k do
{
//для каждой вершины соседа заполняем соответствующую ячейку из матрицы E[n][n] единицей
}

}
</source>

'''Второй этап'''

1. Все связные подграфы в отсортированном порядке помещаются в список;
2. Берем наибольший элемент списка, вычисляем количество его вершин. Если число вершин > l, то идем в пункт 3. Иначе в пункт 5;
3. Разбиваем подграф на два подграфа таким образом, чтобы разделитель ребер графа был минимален и каждый из получаемых подграфов содержал не менее 25 % вершин исходного графа;
4. Добавляем полученные элементы в список подграфов таким образом, чтобы список оставался отсортированным. Идем в пункт 2;
5. Нашли искомое множество подграфов math>K = \{K_{i}\}</math>;
6. Создаем и заполняем матрицу матрицу расстояний для графа <math>G_{2} = (K, E_{2})</math>. Получаем искомый набор рёбер <math>E_{2}</math>.

'''Третий этап'''

1. Заводим два массива: а) массив кластеров C, полученных на предыдущем этапе, б) массив объединений кластеров F, которые мы будем получать на этом этапе;
2. Берем следующий кластер <math>C_{i}</math> (на первом шаге - первый). Если все кластеры просмотрены, идем в пункт 6;
3. Берем следующий кластер <math>C_{j}, i<>j</math>. Если все кластеры просмотрены, то идем в пункт 2;
4. Проверяем смежность <math>C_{i}</math> и <math>C_{j}</math>. Если не смежны, то возвращаемся в пункт 3. Если смежны, идем в пункт 5;
5. Рассчитываем показатели <math>RI_{(C_{i},C_{j})}</math> и <math> RC_{(C_{i},C_{j})}</math>. Проверяем, удовлетворяют ли найденные значения условиям:
*<math>RI_{(C_{i},C_{j})} \geqslant T_{RI}</math>
*<math>RC_{(C_{i},C_{j})} \geqslant T_{RC}</math>
Если нет, то идем в пункт 3. Иначе если смежность пары кластеров выше, чем у предыдущих найденных, то <math>F_{i}=j</math>. Идем в пункт 3;
6. Если в списке F есть хотя бы одна пара кластеров для слияния, то выполняем слияние, обновляем массив кластеров и массив объединений кластеров. Идем в пункт 2.

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

1) Для построения графа на основе метода k ближайших соседей для n вершин требуется <math>O(n log(n))</math> операций <ref>J.H. Friedman, J.L. Bentley, and R.A. Finkel. An algorithm for ﬁnding best matches in logarithmic expected time. ACM Transactions on Mathematical Software, 3:209–226, 1977.</ref>; для наборов данных большой размерности эта величина составляет <math>O(n^2)</math> операций <ref>S. Berchtold, C. Bohm, D. Keim, and H.-P. Kriegel. Cost model for nearest neighbor search in high dimensional data space. In Proc. of Symposium on Principles of Database Systems, Tucson, Arizona, 1997.</ref>;

2) Для выделения множества сравнительно малых связных подграфов требуется <math>nm</math> операций, где <math>m</math> - количество подграфов, полученных на втором этапе алгоритма;

3) Формирование набора кластеров, на основе множества подграфов, полученных на предыдущем этапе, требует <math>m^2log(m)</math> операций.

Итого, для n вершин получаем последовательную сложность <math>O(n log(n)+nm+m^2log(m))</math>.

== Информационный граф ==
[[File:СК.png]]

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

Первый этап работы алгоритма можно распределить между <math>n</math> процессами. На вход каждому процессу подается своя вершина, далее происходит процедура поиска <math>k</math> ближайших соседей. Параллельная сложность составляет <math>O(n)</math>.

Второй и третий этапы можно распараллелить частично.

Второй этап распараллеливается путем подачи на вход свободному процессу очередного подграфа для разделения. Число итераций оценивается в <math>O(n log(n))</math>.

Третий этап делится на расчет показателей схожести и соединение подграфов в кластеры. Процесс расчета показателей можно распараллелить, подавая каждому процессу на вход пару подграфов. Сложность этого процесса оценивается как <math>m log(m)</math>. Соединение подграфов в кластеры выполняется последовательно, сложность процесса составляет <math>m^2 log(m)</math>

Таким образом получаем общую параллельную сложность алгоритма: <math>O(n+ n log(n) + m^2 log (m) + m log(m))</math>

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

1. Симметрическая матрица <math>A</math> расстояний между элементами данных размера <math>n\times n</math> с нулями на главной диагонали (<math>a_{ii}= 0, i = 1, \ldots, N</math>).

2. <math>k</math> - количество ближайших соседей для вершин (рекомендуемое значение <math>k</math> от 5 до 20 в зависимости от количества анализируемых объектов).

3. <math>l</math> - наименьшее число вершин, которое может содержать наибольший подкластер на 2-м этапе . Величина этого параметра варьируется от 1 до 5 % от общего числа объектов.

'''Объём входных данных'''

<math>\frac{n (n - 1)}{2}</math> (в силу симметричности и нулевой главной диагонали достаточно хранить только над/поддиагональные элементы).

'''Выходные данные'''

Вектор из <math>n</math> чисел <math>u_{1}, u_{2}, \ldots, u_{N}</math>, где <math>u_{i}</math> - целое число, соответствующее кластеру <math>i</math>-го объекта.

'''Объём выходных данных'''

<math>n</math>

== Свойства алгоритма ==
Соотношение последовательной и параллельной сложности на первом этапе является ''линейным'' для больших наборов данных и логарифмическим для n вершин. На втором этапе сложно оценить это соотношение - оно сильно зависит от параметров <math>k</math> и <math>l</math>. На третьем этапе соотношение равно <math>O(1)</math>;

Оценка ''вычислительной мощности'' выглядит следующим образом:

<math>O(1)</math> для 1-го этапа;

<math>O(\frac{nm}{n^2+m^2})</math> для 2-го этапа;

<math>O(\frac{m^2log(m)}{m^2+n})</math> для 3-го этапа;

Алгоритм является ''недетерминированным''. Хотя 1-й этап детерминирован, на 2-ом этапе могут быть найдены различные разбиения на подграфы, что повлияет и на итоговый результат работы алгоритма.

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

[[File:Масштабирование.jpg|700px|center|Рис.3 Масштабируемость алгоритма динамической иерархической кластеризации CHAMELEON в зависимости от числа процессоров и размера задачи]]

== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Последовательная реализация алгоритма доступна по ссылке <ref>http://read.pudn.com/downloads36/sourcecode/math/115779/chameleon/chameleon.c__.htm</ref>.

CHAMELEON можно реализовать с использованием графовых библиотек METIS <ref>http://glaros.dtc.umn.edu/gkhome/metis/metis/overview
</ref>, hMETIS <ref>http://glaros.dtc.umn.edu/gkhome/metis/hmetis/overview</ref> и RANN <ref>https://cran.r-project.org/web/packages/RANN/index.html</ref>.

Существует исследование, связанное с реализацией CHAMELEON посредством технологии OpenMP, оно было рассмотрено в пункте 2.4.

Параллельных реализаций алгоритма CHAMELEON не найдено.

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

Участник:ЕкатеринаКозырева/Алгоритм динамической иерархической кластеризации CHAMELEON

2016-12-03T19:15:02Z

ЕкатеринаКозырева: /* Масштабируемость алгоритма и его реализации */

{{Assignment|Kronberg}}
{{algorithm
| name = Алгоритм динамической иерархической кластеризации CHAMELEON
| serial_complexity = <math>O(nm + n log n + m^2 log m)</math>
| input_data = <math>\frac{n (n - 1)}{2}</math>
| output_data = <math>n</math>
| pf_height = <math>O(n+ n log(n) + m^2 log (m) + m log(m))</math>
| pf_width = <math>O(n)</math>
}}

Автор описания [[Участник:ЕкатеринаКозырева|Е.А.Козырева]]
= Свойства и структура алгоритмов =

== Общее описание алгоритма ==
Алгоритм CHAMELEON был предложен в 1999 году тремя учеными из университета Миннесоты – George Karypis, Eui-Hong (Sam) Han и Vipin Kumar<ref>George Karypis, Eui-Hong (Sam) Han и Vipin Kumar, «Chameleon: Hierarchical Clustering Using Dynamic Modeling», 1999.</ref>.

Предназначен для решения задач кластеризации. Кластеризация (или кластерный анализ) — это задача разбиения множества объектов на группы, называемые кластерами. Внутри каждой группы должны оказаться «похожие» объекты, а объекты разных группы должны быть как можно более отличны.

CHAMELEON - это агломеративный иерархический алгоритм кластеризации, ключевой особенностью которого является то, что он учитывает и взаимную связность, и сходство при определении наиболее похожей пары подкластеров, основываясь на динамической модели. Это означает, что в процессе кластеризации два кластера объединяются, только если их относительная взаимная связность и относительное взаимное сходство являются высокими по отношению к внутренней взаимосвязанности кластеров и близости элементов внутри кластеров. Кроме того, CHAMELEON использует подход для моделирования степени взаимосвязанности и близости между каждой парой кластеров, который учитывает внутренние характеристики самих кластеров. Таким образом, он может автоматически адаптироваться к внутренним характеристикам объединяемых кластеров.

CHAMELEON находит кластеры в наборе данных с помощью трехфазного алгоритма. На первой фазе происходит построение графа, путём добавления рёбер по принципу k ближайших соседей. На второй фазе CHAMELEON группирует полученные элементы в множество относительно небольших подграфов. Во время третьей фазы применяется агломеративный иерархический алгоритм кластеризации, с помощью которого находятся естесственные кластеры путем многократного объединения подграфов, полученных на прошлом этапе.

[[File:Chameleon.png|1000px|thumb|center|Рисунок 1. Общая структура алгоритма CHAMELEON]]

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

''Исходные данные'':

* Множество из n точек <math>V= {v_{ij}}</math> в метрическом пространстве, которое задано симметрической матрицей расстояний <math>A</math> размера <math>n\times n</math>.
* <math>k</math> - количество ближайших соседей для вершин, <math>k \in N, k \leq n</math>.
* <math>l</math> - наименьшее число вершин, которое может содержать наибольший подграф на 2-м этапе, <math>l \in N, l \leq n</math>.

''Обозначения'':

* <math>G = (V, E)</math> - граф, полученный путём соединения каждой точки с её <math>k</math> ближайшими соседями.

* <math>K= \{K_{i}\}</math> - разбиение множества <math>V</math> на набор попарно непересекающихся связных подмножеств, полученное в результате выполнения второй фазы алгоритма.

* <math>G_{2} = (K, E_{2})</math> - взвешенный граф, вершинами которого являются получившиеся подграфы, а ребрами - количество ребер исходного графа, соединяющих соответствующие подграфы.

* <math>C = \{C_{i}\}</math> - итоговое разбиение множества вершин графа <math>G_{2}</math> на набор кластеров.

''Вспомогательные понятия''

*<math>EC_{(C_{i},C_{j})}</math> - абсолютная взаимная связность пары кластеров <math>C_{i}, C{j}</math>. Определяется как сумма весов ребер, соединяющих вершины, принадлежащие <math>C{i}</math> c вершинами из <math>C{j}</math>. Внутренняя связность <math>EC_{(C_{i},C_{i})}</math> вычисляется как сумма ребер, входящих в разделитель, разбивающий <math>C{i}</math> на два равных подграфа.

*<math>RI_{(C_{i},C_{j})} = \frac{|EC_{(C_{i},C_{j})}|}{(|EC_{C_{i}}|+|EC_{C_{j}}|)/2}</math> - относительная взаимная связность пары кластеров <math>C_{i}, C{j}</math>

*<math>S_{EC_{(C_{i},C_{j})}}</math> - абсолютное взаимное сходство пары кластеров <math>C_{i}, C{j}</math>. Подсчитывается как среднее сходство между соединенными вершинами, принадлежащими <math>C{i}</math> и <math>C{j}</math> соответственно. Соединения обусловлены разбиением общего графа, полученного на первом этапе алгоритма.

*<math> RC_{(C_{i},C_{j})}= \frac{S_{EC_{(C_{i},C_{j})}}}{\frac{|C_{i}|}{|C_{i}+C_{j}|}*S_{EC_{(C_{i})}}+\frac{|C_{i}|}{|C_{i}+C_{j}|}*S_{EC_{(C_{j})}}}</math> - относительное взаимное сходство пары кластеров <math>C_{i}, C{j}</math>. Определяется как абсолютное сходство между этой парой кластеров, нормализованное с учетом их внутреннего сходства<ref>http://studopedia.ru/7_41934_algoritm-dinamicheskoy-ierarhicheskoy-klasterizatsii-CHAMELEON.html</ref>.

'''Первый этап'''

На первом этапе, согласно графо-ориентированному подходу, происходит построение графа <math>G = (V, E)</math> на матрице сходства объектов по принципу k ближайших соседей. Две вершины такого графа соединяет ребро, если объект, соответствующий любой из этих вершин попадает в число k наиболее близких объектов для объекта, соответствующего другой вершине из данной пары.
[[Файл:Снимок chameleon 2.png|2000px|thumb|Рисунок 2. Объекты в пространстве - слева, граф по принципу 1-го ближайшего соседа - по центру, граф по принципу 3-х ближайших соседей - справа ]]

'''Второй этап'''

Алгоритм разделяет полученный граф на множество сравнительно малых подграфов <math>K= \{K_{i}\}</math>. Разделение происходит последовательно. На каждом шаге выбирается подграф, содержащий наибольшее число вершин. Этот граф разделяется на два подграфа так, что разделитель ребер графа минимален и каждый из получаемых подграфов содержит не менее 25 % вершин исходного графа. Процесс разделения останавливается, когда наибольший подграф содержит меньше некоторого заданного числа вершин. Обычно величина этого параметра задается равной значению от 1 до 5 % от числа объектов. Полученное множество связных графов считается множеством начальных кластеров, на котором требуется провести последовательное иерархическое объединение.

'''Третий этап'''

Третий этап заключается в итеративном преобразовании множества подграфов <math>K= \{K_{i}\}</math> в множество кластеров <math>C = \{C_{i}\}</math>. Алгоритм осуществляет агломеративную иерархическую кластеризацию на основании показателей <math>EC_{(C_{i},C_{j})}</math>, <math>S_{EC_{(C_{i},C_{j})}}</math>, <math>RI_{(C_{i},C_{j})} </math>, <math> RC_{(C_{i},C_{j})}</math>. Существует две стратегии анализа показателей сходства. Первая подразумевает наличие некоторых пороговых значений <math>T_{RI}</math> и <math>T_{RC}</math>. В соответствии с этой стратегией, алгоритм для каждого кластера <math>C_{i}</math> проверяет, отвечают ли смежные (наиболее близкие) ему кластеры условиям:

*<math>RI_{(C_{i},C_{j})} \geqslant T_{RI}</math>

*<math>RC_{(C_{i},C_{j})} \geqslant T_{RC}</math>

Если более одного смежного кластера отвечает этим условиям, то алгоритм выбирает для объединения наиболее связный кластер (граф), то есть такой кластер <math>C_{j}</math>, с которым у кластера <math>C_{i}</math> получается наибольшая абсолютная взаимная связность. По завершению прохода по всем кластерам, созданные таким образом пары объединяются. Параметры <math>T_{RI}</math> и <math>T_{RC}</math> могут использоваться для изменения характеристик получаемых кластеров.

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

<math>RI_{(C_{i},C_{j})}*RC_{(C_{i},C_{j})}^\alpha</math>,

где <math>\alpha</math> выбирается пользователем. Если <math>\alpha > 1 </math>, то алгоритм придает большее значение относительному взаимному сходству, а если <math>\alpha < 1 </math>, то большее значение имеет относительная взаимная связность.

''Вычисляемые данные'':

<math>U = (u_1, u_2, ..., u_n)</math> - n-мерный вектор, где <math>u_i \in N_{[C]}</math> - порядковый номер кластера, к которому принадлежит вершина i исходного множества V.

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

Алгоритм имеет три вычислительных ядра, по одному на каждый этап.

На первом этапе вычислительным ядром является процесс нахождения <math>k</math> ближайших соседей для каждой вершины, который заключается в анализе матрицы расстояний.

На втором этапе вычислительным ядром является процесс поиска подходящего разбиения очередного подграфа на два графа с минимизацией разделителя ребер графа.

На третьем этапе вычислительным ядром является расчет величин <math>EC_{(C_{i},C_{j})}</math>, <math>S_{EC_{(C_{i},C_{j})}}</math>, <math>RI_{(C_{i},C_{j})} </math>, <math> RC_{(C_{i},C_{j})}</math> для каждой пары смежных кластеров.

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

Как уже рассказывалось ранее, алгоритм включает в себя три основных этапа, каждый из которых, по сути, является отдельным алгоритмом. Этапы выполняются последовательно относительно друг друга.

Макрооперация на первом этапе - процедура нахождения <math>k</math> ближайших соседей, на втором - процедура разбиения наибольшего подграфа на два графа, на третьем - процедура вычисления показателей сходства, на основе которых принимается решение о слиянии подграфов в кластер.

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

'''Первый этап'''
<source lang="cpp">
int n; //количество вершин
int k; //количество соседей
int A[n][n] //матрица расстояний
int D[k] //массив вершин-соседей
int E[n][n] //матрица ребер графа <math>G_{2} = (K, E_{2})</math>
for i=1 to n-1 do
{
for j=i+1 to n do
{
//заполняем массив вершин-соседей вставляя новые вершины, если они ближе, чем самая далекая из массива.
}
for j=0 to k do
{
//для каждой вершины соседа заполняем соответствующую ячейку из матрицы E[n][n] единицей
}

}
</source>

'''Второй этап'''

1. Все связные подграфы в отсортированном порядке помещаются в список;
2. Берем наибольший элемент списка, вычисляем количество его вершин. Если число вершин > l, то идем в пункт 3. Иначе в пункт 5;
3. Разбиваем подграф на два подграфа таким образом, чтобы разделитель ребер графа был минимален и каждый из получаемых подграфов содержал не менее 25 % вершин исходного графа;
4. Добавляем полученные элементы в список подграфов таким образом, чтобы список оставался отсортированным. Идем в пункт 2;
5. Нашли искомое множество подграфов math>K = \{K_{i}\}</math>;
6. Создаем и заполняем матрицу матрицу расстояний для графа <math>G_{2} = (K, E_{2})</math>. Получаем искомый набор рёбер <math>E_{2}</math>.

'''Третий этап'''

1. Заводим два массива: а) массив кластеров C, полученных на предыдущем этапе, б) массив объединений кластеров F, которые мы будем получать на этом этапе;
2. Берем следующий кластер <math>C_{i}</math> (на первом шаге - первый). Если все кластеры просмотрены, идем в пункт 6;
3. Берем следующий кластер <math>C_{j}, i<>j</math>. Если все кластеры просмотрены, то идем в пункт 2;
4. Проверяем смежность <math>C_{i}</math> и <math>C_{j}</math>. Если не смежны, то возвращаемся в пункт 3. Если смежны, идем в пункт 5;
5. Рассчитываем показатели <math>RI_{(C_{i},C_{j})}</math> и <math> RC_{(C_{i},C_{j})}</math>. Проверяем, удовлетворяют ли найденные значения условиям:
*<math>RI_{(C_{i},C_{j})} \geqslant T_{RI}</math>
*<math>RC_{(C_{i},C_{j})} \geqslant T_{RC}</math>
Если нет, то идем в пункт 3. Иначе если смежность пары кластеров выше, чем у предыдущих найденных, то <math>F_{i}=j</math>. Идем в пункт 3;
6. Если в списке F есть хотя бы одна пара кластеров для слияния, то выполняем слияние, обновляем массив кластеров и массив объединений кластеров. Идем в пункт 2.

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

1) Для построения графа на основе метода k ближайших соседей для n вершин требуется <math>O(n log(n))</math> операций <ref>J.H. Friedman, J.L. Bentley, and R.A. Finkel. An algorithm for ﬁnding best matches in logarithmic expected time. ACM Transactions on Mathematical Software, 3:209–226, 1977.</ref>; для наборов данных большой размерности эта величина составляет <math>O(n^2)</math> операций <ref>S. Berchtold, C. Bohm, D. Keim, and H.-P. Kriegel. Cost model for nearest neighbor search in high dimensional data space. In Proc. of Symposium on Principles of Database Systems, Tucson, Arizona, 1997.</ref>;

2) Для выделения множества сравнительно малых связных подграфов требуется <math>nm</math> операций, где <math>m</math> - количество подграфов, полученных на втором этапе алгоритма;

3) Формирование набора кластеров, на основе множества подграфов, полученных на предыдущем этапе, требует <math>m^2log(m)</math> операций.

Итого, для n вершин получаем последовательную сложность <math>O(n log(n)+nm+m^2log(m))</math>.

== Информационный граф ==
[[File:СК.png]]

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

Первый этап работы алгоритма можно распределить между <math>n</math> процессами. На вход каждому процессу подается своя вершина, далее происходит процедура поиска <math>k</math> ближайших соседей. Параллельная сложность составляет <math>O(n)</math>.

Второй и третий этапы можно распараллелить частично.

Второй этап распараллеливается путем подачи на вход свободному процессу очередного подграфа для разделения. Число итераций оценивается в <math>O(n log(n))</math>.

Третий этап делится на расчет показателей схожести и соединение подграфов в кластеры. Процесс расчета показателей можно распараллелить, подавая каждому процессу на вход пару подграфов. Сложность этого процесса оценивается как <math>m log(m)</math>. Соединение подграфов в кластеры выполняется последовательно, сложность процесса составляет <math>m^2 log(m)</math>

Таким образом получаем общую параллельную сложность алгоритма: <math>O(n+ n log(n) + m^2 log (m) + m log(m))</math>

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

1. Симметрическая матрица <math>A</math> расстояний между элементами данных размера <math>n\times n</math> с нулями на главной диагонали (<math>a_{ii}= 0, i = 1, \ldots, N</math>).

2. <math>k</math> - количество ближайших соседей для вершин (рекомендуемое значение <math>k</math> от 5 до 20 в зависимости от количества анализируемых объектов).

3. <math>l</math> - наименьшее число вершин, которое может содержать наибольший подкластер на 2-м этапе . Величина этого параметра варьируется от 1 до 5 % от общего числа объектов.

'''Объём входных данных'''

<math>\frac{n (n - 1)}{2}</math> (в силу симметричности и нулевой главной диагонали достаточно хранить только над/поддиагональные элементы).

'''Выходные данные'''

Вектор из <math>n</math> чисел <math>u_{1}, u_{2}, \ldots, u_{N}</math>, где <math>u_{i}</math> - целое число, соответствующее кластеру <math>i</math>-го объекта.

'''Объём выходных данных'''

<math>n</math>

== Свойства алгоритма ==
Соотношение последовательной и параллельной сложности на первом этапе является ''линейным'' для больших наборов данных и логарифмическим для n вершин. На втором этапе сложно оценить это соотношение - оно сильно зависит от параметров <math>k</math> и <math>l</math>. На третьем этапе соотношение равно <math>O(1)</math>;

Оценка ''вычислительной мощности'' выглядит следующим образом:

<math>O(1)</math> для 1-го этапа;

<math>O(\frac{nm}{n^2+m^2})</math> для 2-го этапа;

<math>O(\frac{m^2log(m)}{m^2+n})</math> для 3-го этапа;

Алгоритм является ''недетерминированным''. Хотя 1-й этап детерминирован, на 2-ом этапе могут быть найдены различные разбиения на подграфы, что повлияет и на итоговый результат работы алгоритма.

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

[[File:Масштабирование.jpg|700px|center]]

== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Последовательная реализация алгоритма доступна по ссылке <ref>http://read.pudn.com/downloads36/sourcecode/math/115779/chameleon/chameleon.c__.htm</ref>.

CHAMELEON можно реализовать с использованием графовых библиотек METIS <ref>http://glaros.dtc.umn.edu/gkhome/metis/metis/overview
</ref>, hMETIS <ref>http://glaros.dtc.umn.edu/gkhome/metis/hmetis/overview</ref> и RANN <ref>https://cran.r-project.org/web/packages/RANN/index.html</ref>.

Существует исследование, связанное с реализацией CHAMELEON посредством технологии OpenMP, оно было рассмотрено в пункте 2.4.

Параллельных реализаций алгоритма CHAMELEON не найдено.

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

Участник:ЕкатеринаКозырева/Алгоритм динамической иерархической кластеризации CHAMELEON

2016-11-20T15:27:42Z

ЕкатеринаКозырева:

{{Assignment}}

{{algorithm
| name = Алгоритм динамической иерархической кластеризации CHAMELEON
| serial_complexity = <math>O(nm + n log n + m^2 log m)</math>
| input_data = <math>\frac{n (n - 1)}{2}</math>
| output_data = <math>n</math>
| pf_height = <math>O(n+ n log(n) + m^2 log (m) + m log(m))</math>
| pf_width = <math>O(n)</math>
}}

Автор описания [[Участник:ЕкатеринаКозырева|Е.А.Козырева]]
= Свойства и структура алгоритмов =

== Общее описание алгоритма ==
Алгоритм CHAMELEON был предложен в 1999 году тремя учеными из университета Миннесоты – George Karypis, Eui-Hong (Sam) Han и Vipin Kumar<ref>George Karypis, Eui-Hong (Sam) Han и Vipin Kumar, «Chameleon: Hierarchical Clustering Using Dynamic Modeling», 1999.</ref>.

Предназначен для решения задач кластеризации. Кластеризация (или кластерный анализ) — это задача разбиения множества объектов на группы, называемые кластерами. Внутри каждой группы должны оказаться «похожие» объекты, а объекты разных группы должны быть как можно более отличны.

CHAMELEON - это агломеративный иерархический алгоритм кластеризации, ключевой особенностью которого является то, что он учитывает и взаимную связность, и сходство при определении наиболее похожей пары подкластеров, основываясь на динамической модели. Это означает, что в процессе кластеризации два кластера объединяются, только если их относительная взаимная связность и относительное взаимное сходство являются высокими по отношению к внутренней взаимосвязанности кластеров и близости элементов внутри кластеров. Кроме того, CHAMELEON использует подход для моделирования степени взаимосвязанности и близости между каждой парой кластеров, который учитывает внутренние характеристики самих кластеров. Таким образом, он может автоматически адаптироваться к внутренним характеристикам объединяемых кластеров.

CHAMELEON находит кластеры в наборе данных с помощью трехфазного алгоритма. На первой фазе происходит построение графа, путём добавления рёбер по принципу k ближайших соседей. На второй фазе CHAMELEON группирует полученные элементы в множество относительно небольших подграфов. Во время третьей фазы применяется агломеративный иерархический алгоритм кластеризации, с помощью которого находятся естесственные кластеры путем многократного объединения подграфов, полученных на прошлом этапе.

[[File:Chameleon.png|1000px|thumb|center|Рисунок 1. Общая структура алгоритма CHAMELEON]]

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

''Исходные данные'':

* Множество из n точек <math>V= {v_{ij}}</math> в метрическом пространстве, которое задано симметрической матрицей расстояний <math>A</math> размера <math>n\times n</math>.
* <math>k</math> - количество ближайших соседей для вершин, <math>k \in N, k \leq n</math>.
* <math>l</math> - наименьшее число вершин, которое может содержать наибольший подграф на 2-м этапе, <math>l \in N, l \leq n</math>.

''Обозначения'':

* <math>G = (V, E)</math> - граф, полученный путём соединения каждой точки с её <math>k</math> ближайшими соседями.

* <math>K= \{K_{i}\}</math> - разбиение множества <math>V</math> на набор попарно непересекающихся связных подмножеств, полученное в результате выполнения второй фазы алгоритма.

* <math>G_{2} = (K, E_{2})</math> - взвешенный граф, вершинами которого являются получившиеся подграфы, а ребрами - количество ребер исходного графа, соединяющих соответствующие подграфы.

* <math>C = \{C_{i}\}</math> - итоговое разбиение множества вершин графа <math>G_{2}</math> на набор кластеров.

''Вспомогательные понятия''

*<math>EC_{(C_{i},C_{j})}</math> - абсолютная взаимная связность пары кластеров <math>C_{i}, C{j}</math>. Определяется как сумма весов ребер, соединяющих вершины, принадлежащие <math>C{i}</math> c вершинами из <math>C{j}</math>. Внутренняя связность <math>EC_{(C_{i},C_{i})}</math> вычисляется как сумма ребер, входящих в разделитель, разбивающий <math>C{i}</math> на два равных подграфа.

*<math>RI_{(C_{i},C_{j})} = \frac{|EC_{(C_{i},C_{j})}|}{(|EC_{C_{i}}|+|EC_{C_{j}}|)/2}</math> - относительная взаимная связность пары кластеров <math>C_{i}, C{j}</math>

*<math>S_{EC_{(C_{i},C_{j})}}</math> - абсолютное взаимное сходство пары кластеров <math>C_{i}, C{j}</math>. Подсчитывается как среднее сходство между соединенными вершинами, принадлежащими <math>C{i}</math> и <math>C{j}</math> соответственно. Соединения обусловлены разбиением общего графа, полученного на первом этапе алгоритма.

*<math> RC_{(C_{i},C_{j})}= \frac{S_{EC_{(C_{i},C_{j})}}}{\frac{|C_{i}|}{|C_{i}+C_{j}|}*S_{EC_{(C_{i})}}+\frac{|C_{i}|}{|C_{i}+C_{j}|}*S_{EC_{(C_{j})}}}</math> - относительное взаимное сходство пары кластеров <math>C_{i}, C{j}</math>. Определяется как абсолютное сходство между этой парой кластеров, нормализованное с учетом их внутреннего сходства<ref>http://studopedia.ru/7_41934_algoritm-dinamicheskoy-ierarhicheskoy-klasterizatsii-CHAMELEON.html</ref>.

'''Первый этап'''

На первом этапе, согласно графо-ориентированному подходу, происходит построение графа <math>G = (V, E)</math> на матрице сходства объектов по принципу k ближайших соседей. Две вершины такого графа соединяет ребро, если объект, соответствующий любой из этих вершин попадает в число k наиболее близких объектов для объекта, соответствующего другой вершине из данной пары.
[[Файл:Снимок chameleon 2.png|2000px|thumb|Рисунок 2. Объекты в пространстве - слева, граф по принципу 1-го ближайшего соседа - по центру, граф по принципу 3-х ближайших соседей - справа ]]

'''Второй этап'''

Алгоритм разделяет полученный граф на множество сравнительно малых подграфов <math>K= \{K_{i}\}</math>. Разделение происходит последовательно. На каждом шаге выбирается подграф, содержащий наибольшее число вершин. Этот граф разделяется на два подграфа так, что разделитель ребер графа минимален и каждый из получаемых подграфов содержит не менее 25 % вершин исходного графа. Процесс разделения останавливается, когда наибольший подграф содержит меньше некоторого заданного числа вершин. Обычно величина этого параметра задается равной значению от 1 до 5 % от числа объектов. Полученное множество связных графов считается множеством начальных кластеров, на котором требуется провести последовательное иерархическое объединение.

'''Третий этап'''

Третий этап заключается в итеративном преобразовании множества подграфов <math>K= \{K_{i}\}</math> в множество кластеров <math>C = \{C_{i}\}</math>. Алгоритм осуществляет агломеративную иерархическую кластеризацию на основании показателей <math>EC_{(C_{i},C_{j})}</math>, <math>S_{EC_{(C_{i},C_{j})}}</math>, <math>RI_{(C_{i},C_{j})} </math>, <math> RC_{(C_{i},C_{j})}</math>. Существует две стратегии анализа показателей сходства. Первая подразумевает наличие некоторых пороговых значений <math>T_{RI}</math> и <math>T_{RC}</math>. В соответствии с этой стратегией, алгоритм для каждого кластера <math>C_{i}</math> проверяет, отвечают ли смежные (наиболее близкие) ему кластеры условиям:

*<math>RI_{(C_{i},C_{j})} \geqslant T_{RI}</math>

*<math>RC_{(C_{i},C_{j})} \geqslant T_{RC}</math>

Если более одного смежного кластера отвечает этим условиям, то алгоритм выбирает для объединения наиболее связный кластер (граф), то есть такой кластер <math>C_{j}</math>, с которым у кластера <math>C_{i}</math> получается наибольшая абсолютная взаимная связность. По завершению прохода по всем кластерам, созданные таким образом пары объединяются. Параметры <math>T_{RI}</math> и <math>T_{RC}</math> могут использоваться для изменения характеристик получаемых кластеров.

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

<math>RI_{(C_{i},C_{j})}*RC_{(C_{i},C_{j})}^\alpha</math>,

где <math>\alpha</math> выбирается пользователем. Если <math>\alpha > 1 </math>, то алгоритм придает большее значение относительному взаимному сходству, а если <math>\alpha < 1 </math>, то большее значение имеет относительная взаимная связность.

''Вычисляемые данные'':

<math>U = (u_1, u_2, ..., u_n)</math> - n-мерный вектор, где <math>u_i \in N_{[C]}</math> - порядковый номер кластера, к которому принадлежит вершина i исходного множества V.

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

Алгоритм имеет три вычислительных ядра, по одному на каждый этап.

На первом этапе вычислительным ядром является процесс нахождения <math>k</math> ближайших соседей для каждой вершины, который заключается в анализе матрицы расстояний.

На втором этапе вычислительным ядром является процесс поиска подходящего разбиения очередного подграфа на два графа с минимизацией разделителя ребер графа.

На третьем этапе вычислительным ядром является расчет величин <math>EC_{(C_{i},C_{j})}</math>, <math>S_{EC_{(C_{i},C_{j})}}</math>, <math>RI_{(C_{i},C_{j})} </math>, <math> RC_{(C_{i},C_{j})}</math> для каждой пары смежных кластеров.

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

Как уже рассказывалось ранее, алгоритм включает в себя три основных этапа, каждый из которых, по сути, является отдельным алгоритмом. Этапы выполняются последовательно относительно друг друга.

Макрооперация на первом этапе - процедура нахождения <math>k</math> ближайших соседей, на втором - процедура разбиения наибольшего подграфа на два графа, на третьем - процедура вычисления показателей сходства, на основе которых принимается решение о слиянии подграфов в кластер.

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

'''Первый этап'''
<source lang="cpp">
int n; //количество вершин
int k; //количество соседей
int A[n][n] //матрица расстояний
int D[k] //массив вершин-соседей
int E[n][n] //матрица ребер графа <math>G_{2} = (K, E_{2})</math>
for i=1 to n-1 do
{
for j=i+1 to n do
{
//заполняем массив вершин-соседей вставляя новые вершины, если они ближе, чем самая далекая из массива.
}
for j=0 to k do
{
//для каждой вершины соседа заполняем соответствующую ячейку из матрицы E[n][n] единицей
}

}
</source>

'''Второй этап'''

1. Все связные подграфы в отсортированном порядке помещаются в список;
2. Берем наибольший элемент списка, вычисляем количество его вершин. Если число вершин > l, то идем в пункт 3. Иначе в пункт 5;
3. Разбиваем подграф на два подграфа таким образом, чтобы разделитель ребер графа был минимален и каждый из получаемых подграфов содержал не менее 25 % вершин исходного графа;
4. Добавляем полученные элементы в список подграфов таким образом, чтобы список оставался отсортированным. Идем в пункт 2;
5. Нашли искомое множество подграфов math>K = \{K_{i}\}</math>;
6. Создаем и заполняем матрицу матрицу расстояний для графа <math>G_{2} = (K, E_{2})</math>. Получаем искомый набор рёбер <math>E_{2}</math>.

'''Третий этап'''

1. Заводим два массива: а) массив кластеров C, полученных на предыдущем этапе, б) массив объединений кластеров F, которые мы будем получать на этом этапе;
2. Берем следующий кластер <math>C_{i}</math> (на первом шаге - первый). Если все кластеры просмотрены, идем в пункт 6;
3. Берем следующий кластер <math>C_{j}, i<>j</math>. Если все кластеры просмотрены, то идем в пункт 2;
4. Проверяем смежность <math>C_{i}</math> и <math>C_{j}</math>. Если не смежны, то возвращаемся в пункт 3. Если смежны, идем в пункт 5;
5. Рассчитываем показатели <math>RI_{(C_{i},C_{j})}</math> и <math> RC_{(C_{i},C_{j})}</math>. Проверяем, удовлетворяют ли найденные значения условиям:
*<math>RI_{(C_{i},C_{j})} \geqslant T_{RI}</math>
*<math>RC_{(C_{i},C_{j})} \geqslant T_{RC}</math>
Если нет, то идем в пункт 3. Иначе если смежность пары кластеров выше, чем у предыдущих найденных, то <math>F_{i}=j</math>. Идем в пункт 3;
6. Если в списке F есть хотя бы одна пара кластеров для слияния, то выполняем слияние, обновляем массив кластеров и массив объединений кластеров. Идем в пункт 2.

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

1) Для построения графа на основе метода k ближайших соседей для n вершин требуется <math>O(n log(n))</math> операций <ref>J.H. Friedman, J.L. Bentley, and R.A. Finkel. An algorithm for ﬁnding best matches in logarithmic expected time. ACM Transactions on Mathematical Software, 3:209–226, 1977.</ref>; для наборов данных большой размерности эта величина составляет <math>O(n^2)</math> операций <ref>S. Berchtold, C. Bohm, D. Keim, and H.-P. Kriegel. Cost model for nearest neighbor search in high dimensional data space. In Proc. of Symposium on Principles of Database Systems, Tucson, Arizona, 1997.</ref>;

2) Для выделения множества сравнительно малых связных подграфов требуется <math>nm</math> операций, где <math>m</math> - количество подграфов, полученных на втором этапе алгоритма;

3) Формирование набора кластеров, на основе множества подграфов, полученных на предыдущем этапе, требует <math>m^2log(m)</math> операций.

Итого, для n вершин получаем последовательную сложность <math>O(n log(n)+nm+m^2log(m))</math>.

== Информационный граф ==
[[File:СК.png]]

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

Первый этап работы алгоритма можно распределить между <math>n</math> процессами. На вход каждому процессу подается своя вершина, далее происходит процедура поиска <math>k</math> ближайших соседей. Параллельная сложность составляет <math>O(n)</math>.

Второй и третий этапы можно распараллелить частично.

Второй этап распараллеливается путем подачи на вход свободному процессу очередного подграфа для разделения. Число итераций оценивается в <math>O(n log(n))</math>.

Третий этап делится на расчет показателей схожести и соединение подграфов в кластеры. Процесс расчета показателей можно распараллелить, подавая каждому процессу на вход пару подграфов. Сложность этого процесса оценивается как <math>m log(m)</math>. Соединение подграфов в кластеры выполняется последовательно, сложность процесса составляет <math>m^2 log(m)</math>

Таким образом получаем общую параллельную сложность алгоритма: <math>O(n+ n log(n) + m^2 log (m) + m log(m))</math>

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

1. Симметрическая матрица <math>A</math> расстояний между элементами данных размера <math>n\times n</math> с нулями на главной диагонали (<math>a_{ii}= 0, i = 1, \ldots, N</math>).

2. <math>k</math> - количество ближайших соседей для вершин (рекомендуемое значение <math>k</math> от 5 до 20 в зависимости от количества анализируемых объектов).

3. <math>l</math> - наименьшее число вершин, которое может содержать наибольший подкластер на 2-м этапе . Величина этого параметра варьируется от 1 до 5 % от общего числа объектов.

'''Объём входных данных'''

<math>\frac{n (n - 1)}{2}</math> (в силу симметричности и нулевой главной диагонали достаточно хранить только над/поддиагональные элементы).

'''Выходные данные'''

Вектор из <math>n</math> чисел <math>u_{1}, u_{2}, \ldots, u_{N}</math>, где <math>u_{i}</math> - целое число, соответствующее кластеру <math>i</math>-го объекта.

'''Объём выходных данных'''

<math>n</math>

== Свойства алгоритма ==
Соотношение последовательной и параллельной сложности на первом этапе является ''линейным'' для больших наборов данных и логарифмическим для n вершин. На втором этапе сложно оценить это соотношение - оно сильно зависит от параметров <math>k</math> и <math>l</math>. На третьем этапе соотношение равно <math>O(1)</math>;

Оценка ''вычислительной мощности'' выглядит следующим образом:

<math>O(1)</math> для 1-го этапа;

<math>O(\frac{nm}{n^2+m^2})</math> для 2-го этапа;

<math>O(\frac{m^2log(m)}{m^2+n})</math> для 3-го этапа;

Алгоритм является ''недетерминированным''. Хотя 1-й этап детерминирован, на 2-ом этапе могут быть найдены различные разбиения на подграфы, что повлияет и на итоговый результат работы алгоритма.

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

Масштабируемость исследовалась на основе работы, презентующей пробную версию параллельной реализации алгоритма для различного числа потоков<ref>http://research.ijcaonline.org/volume79/number8/pxc3891600.pdf</ref>.
График показывает, что эффективность и скорость работы алгоритма растут с увеличением объема входных данных. Однако, в упомянутой выше работе отмечается, что эффективность алгоритма падает с ростом количества потоков.

[[File:Масштабирование.png|700px|center]]

== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Последовательная реализация алгоритма доступна по ссылке <ref>http://read.pudn.com/downloads36/sourcecode/math/115779/chameleon/chameleon.c__.htm</ref>.

CHAMELEON можно реализовать с использованием графовых библиотек METIS <ref>http://glaros.dtc.umn.edu/gkhome/metis/metis/overview
</ref>, hMETIS <ref>http://glaros.dtc.umn.edu/gkhome/metis/hmetis/overview</ref> и RANN <ref>https://cran.r-project.org/web/packages/RANN/index.html</ref>.

Существует исследование, связанное с реализацией CHAMELEON посредством технологии OpenMP, оно было рассмотрено в пункте 2.4.

Параллельных реализаций алгоритма CHAMELEON не найдено.

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

Участник:ЕкатеринаКозырева/Алгоритм динамической иерархической кластеризации CHAMELEON

2016-11-20T15:25:32Z

ЕкатеринаКозырева: /* Существующие реализации алгоритма */

{{algorithm
| name = Алгоритм динамической иерархической кластеризации CHAMELEON
| serial_complexity = <math>O(nm + n log n + m^2 log m)</math>
| input_data = <math>\frac{n (n - 1)}{2}</math>
| output_data = <math>n</math>
| pf_height = <math>O(n+ n log(n) + m^2 log (m) + m log(m))</math>
| pf_width = <math>O(n)</math>
}}

Автор описания [[Участник:ЕкатеринаКозырева|Е.А.Козырева]]
= Свойства и структура алгоритмов =

== Общее описание алгоритма ==
Алгоритм CHAMELEON был предложен в 1999 году тремя учеными из университета Миннесоты – George Karypis, Eui-Hong (Sam) Han и Vipin Kumar<ref>George Karypis, Eui-Hong (Sam) Han и Vipin Kumar, «Chameleon: Hierarchical Clustering Using Dynamic Modeling», 1999.</ref>.

Предназначен для решения задач кластеризации. Кластеризация (или кластерный анализ) — это задача разбиения множества объектов на группы, называемые кластерами. Внутри каждой группы должны оказаться «похожие» объекты, а объекты разных группы должны быть как можно более отличны.

CHAMELEON - это агломеративный иерархический алгоритм кластеризации, ключевой особенностью которого является то, что он учитывает и взаимную связность, и сходство при определении наиболее похожей пары подкластеров, основываясь на динамической модели. Это означает, что в процессе кластеризации два кластера объединяются, только если их относительная взаимная связность и относительное взаимное сходство являются высокими по отношению к внутренней взаимосвязанности кластеров и близости элементов внутри кластеров. Кроме того, CHAMELEON использует подход для моделирования степени взаимосвязанности и близости между каждой парой кластеров, который учитывает внутренние характеристики самих кластеров. Таким образом, он может автоматически адаптироваться к внутренним характеристикам объединяемых кластеров.

CHAMELEON находит кластеры в наборе данных с помощью трехфазного алгоритма. На первой фазе происходит построение графа, путём добавления рёбер по принципу k ближайших соседей. На второй фазе CHAMELEON группирует полученные элементы в множество относительно небольших подграфов. Во время третьей фазы применяется агломеративный иерархический алгоритм кластеризации, с помощью которого находятся естесственные кластеры путем многократного объединения подграфов, полученных на прошлом этапе.

[[File:Chameleon.png|1000px|thumb|center|Рисунок 1. Общая структура алгоритма CHAMELEON]]

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

''Исходные данные'':

* Множество из n точек <math>V= {v_{ij}}</math> в метрическом пространстве, которое задано симметрической матрицей расстояний <math>A</math> размера <math>n\times n</math>.
* <math>k</math> - количество ближайших соседей для вершин, <math>k \in N, k \leq n</math>.
* <math>l</math> - наименьшее число вершин, которое может содержать наибольший подграф на 2-м этапе, <math>l \in N, l \leq n</math>.

''Обозначения'':

* <math>G = (V, E)</math> - граф, полученный путём соединения каждой точки с её <math>k</math> ближайшими соседями.

* <math>K= \{K_{i}\}</math> - разбиение множества <math>V</math> на набор попарно непересекающихся связных подмножеств, полученное в результате выполнения второй фазы алгоритма.

* <math>G_{2} = (K, E_{2})</math> - взвешенный граф, вершинами которого являются получившиеся подграфы, а ребрами - количество ребер исходного графа, соединяющих соответствующие подграфы.

* <math>C = \{C_{i}\}</math> - итоговое разбиение множества вершин графа <math>G_{2}</math> на набор кластеров.

''Вспомогательные понятия''

*<math>EC_{(C_{i},C_{j})}</math> - абсолютная взаимная связность пары кластеров <math>C_{i}, C{j}</math>. Определяется как сумма весов ребер, соединяющих вершины, принадлежащие <math>C{i}</math> c вершинами из <math>C{j}</math>. Внутренняя связность <math>EC_{(C_{i},C_{i})}</math> вычисляется как сумма ребер, входящих в разделитель, разбивающий <math>C{i}</math> на два равных подграфа.

*<math>RI_{(C_{i},C_{j})} = \frac{|EC_{(C_{i},C_{j})}|}{(|EC_{C_{i}}|+|EC_{C_{j}}|)/2}</math> - относительная взаимная связность пары кластеров <math>C_{i}, C{j}</math>

*<math>S_{EC_{(C_{i},C_{j})}}</math> - абсолютное взаимное сходство пары кластеров <math>C_{i}, C{j}</math>. Подсчитывается как среднее сходство между соединенными вершинами, принадлежащими <math>C{i}</math> и <math>C{j}</math> соответственно. Соединения обусловлены разбиением общего графа, полученного на первом этапе алгоритма.

*<math> RC_{(C_{i},C_{j})}= \frac{S_{EC_{(C_{i},C_{j})}}}{\frac{|C_{i}|}{|C_{i}+C_{j}|}*S_{EC_{(C_{i})}}+\frac{|C_{i}|}{|C_{i}+C_{j}|}*S_{EC_{(C_{j})}}}</math> - относительное взаимное сходство пары кластеров <math>C_{i}, C{j}</math>. Определяется как абсолютное сходство между этой парой кластеров, нормализованное с учетом их внутреннего сходства<ref>http://studopedia.ru/7_41934_algoritm-dinamicheskoy-ierarhicheskoy-klasterizatsii-CHAMELEON.html</ref>.

'''Первый этап'''

На первом этапе, согласно графо-ориентированному подходу, происходит построение графа <math>G = (V, E)</math> на матрице сходства объектов по принципу k ближайших соседей. Две вершины такого графа соединяет ребро, если объект, соответствующий любой из этих вершин попадает в число k наиболее близких объектов для объекта, соответствующего другой вершине из данной пары.
[[Файл:Снимок chameleon 2.png|2000px|thumb|Рисунок 2. Объекты в пространстве - слева, граф по принципу 1-го ближайшего соседа - по центру, граф по принципу 3-х ближайших соседей - справа ]]

'''Второй этап'''

Алгоритм разделяет полученный граф на множество сравнительно малых подграфов <math>K= \{K_{i}\}</math>. Разделение происходит последовательно. На каждом шаге выбирается подграф, содержащий наибольшее число вершин. Этот граф разделяется на два подграфа так, что разделитель ребер графа минимален и каждый из получаемых подграфов содержит не менее 25 % вершин исходного графа. Процесс разделения останавливается, когда наибольший подграф содержит меньше некоторого заданного числа вершин. Обычно величина этого параметра задается равной значению от 1 до 5 % от числа объектов. Полученное множество связных графов считается множеством начальных кластеров, на котором требуется провести последовательное иерархическое объединение.

'''Третий этап'''

Третий этап заключается в итеративном преобразовании множества подграфов <math>K= \{K_{i}\}</math> в множество кластеров <math>C = \{C_{i}\}</math>. Алгоритм осуществляет агломеративную иерархическую кластеризацию на основании показателей <math>EC_{(C_{i},C_{j})}</math>, <math>S_{EC_{(C_{i},C_{j})}}</math>, <math>RI_{(C_{i},C_{j})} </math>, <math> RC_{(C_{i},C_{j})}</math>. Существует две стратегии анализа показателей сходства. Первая подразумевает наличие некоторых пороговых значений <math>T_{RI}</math> и <math>T_{RC}</math>. В соответствии с этой стратегией, алгоритм для каждого кластера <math>C_{i}</math> проверяет, отвечают ли смежные (наиболее близкие) ему кластеры условиям:

*<math>RI_{(C_{i},C_{j})} \geqslant T_{RI}</math>

*<math>RC_{(C_{i},C_{j})} \geqslant T_{RC}</math>

Если более одного смежного кластера отвечает этим условиям, то алгоритм выбирает для объединения наиболее связный кластер (граф), то есть такой кластер <math>C_{j}</math>, с которым у кластера <math>C_{i}</math> получается наибольшая абсолютная взаимная связность. По завершению прохода по всем кластерам, созданные таким образом пары объединяются. Параметры <math>T_{RI}</math> и <math>T_{RC}</math> могут использоваться для изменения характеристик получаемых кластеров.

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

<math>RI_{(C_{i},C_{j})}*RC_{(C_{i},C_{j})}^\alpha</math>,

где <math>\alpha</math> выбирается пользователем. Если <math>\alpha > 1 </math>, то алгоритм придает большее значение относительному взаимному сходству, а если <math>\alpha < 1 </math>, то большее значение имеет относительная взаимная связность.

''Вычисляемые данные'':

<math>U = (u_1, u_2, ..., u_n)</math> - n-мерный вектор, где <math>u_i \in N_{[C]}</math> - порядковый номер кластера, к которому принадлежит вершина i исходного множества V.

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

Алгоритм имеет три вычислительных ядра, по одному на каждый этап.

На первом этапе вычислительным ядром является процесс нахождения <math>k</math> ближайших соседей для каждой вершины, который заключается в анализе матрицы расстояний.

На втором этапе вычислительным ядром является процесс поиска подходящего разбиения очередного подграфа на два графа с минимизацией разделителя ребер графа.

На третьем этапе вычислительным ядром является расчет величин <math>EC_{(C_{i},C_{j})}</math>, <math>S_{EC_{(C_{i},C_{j})}}</math>, <math>RI_{(C_{i},C_{j})} </math>, <math> RC_{(C_{i},C_{j})}</math> для каждой пары смежных кластеров.

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

Как уже рассказывалось ранее, алгоритм включает в себя три основных этапа, каждый из которых, по сути, является отдельным алгоритмом. Этапы выполняются последовательно относительно друг друга.

Макрооперация на первом этапе - процедура нахождения <math>k</math> ближайших соседей, на втором - процедура разбиения наибольшего подграфа на два графа, на третьем - процедура вычисления показателей сходства, на основе которых принимается решение о слиянии подграфов в кластер.

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

'''Первый этап'''
<source lang="cpp">
int n; //количество вершин
int k; //количество соседей
int A[n][n] //матрица расстояний
int D[k] //массив вершин-соседей
int E[n][n] //матрица ребер графа <math>G_{2} = (K, E_{2})</math>
for i=1 to n-1 do
{
for j=i+1 to n do
{
//заполняем массив вершин-соседей вставляя новые вершины, если они ближе, чем самая далекая из массива.
}
for j=0 to k do
{
//для каждой вершины соседа заполняем соответствующую ячейку из матрицы E[n][n] единицей
}

}
</source>

'''Второй этап'''

1. Все связные подграфы в отсортированном порядке помещаются в список;
2. Берем наибольший элемент списка, вычисляем количество его вершин. Если число вершин > l, то идем в пункт 3. Иначе в пункт 5;
3. Разбиваем подграф на два подграфа таким образом, чтобы разделитель ребер графа был минимален и каждый из получаемых подграфов содержал не менее 25 % вершин исходного графа;
4. Добавляем полученные элементы в список подграфов таким образом, чтобы список оставался отсортированным. Идем в пункт 2;
5. Нашли искомое множество подграфов math>K = \{K_{i}\}</math>;
6. Создаем и заполняем матрицу матрицу расстояний для графа <math>G_{2} = (K, E_{2})</math>. Получаем искомый набор рёбер <math>E_{2}</math>.

'''Третий этап'''

1. Заводим два массива: а) массив кластеров C, полученных на предыдущем этапе, б) массив объединений кластеров F, которые мы будем получать на этом этапе;
2. Берем следующий кластер <math>C_{i}</math> (на первом шаге - первый). Если все кластеры просмотрены, идем в пункт 6;
3. Берем следующий кластер <math>C_{j}, i<>j</math>. Если все кластеры просмотрены, то идем в пункт 2;
4. Проверяем смежность <math>C_{i}</math> и <math>C_{j}</math>. Если не смежны, то возвращаемся в пункт 3. Если смежны, идем в пункт 5;
5. Рассчитываем показатели <math>RI_{(C_{i},C_{j})}</math> и <math> RC_{(C_{i},C_{j})}</math>. Проверяем, удовлетворяют ли найденные значения условиям:
*<math>RI_{(C_{i},C_{j})} \geqslant T_{RI}</math>
*<math>RC_{(C_{i},C_{j})} \geqslant T_{RC}</math>
Если нет, то идем в пункт 3. Иначе если смежность пары кластеров выше, чем у предыдущих найденных, то <math>F_{i}=j</math>. Идем в пункт 3;
6. Если в списке F есть хотя бы одна пара кластеров для слияния, то выполняем слияние, обновляем массив кластеров и массив объединений кластеров. Идем в пункт 2.

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

1) Для построения графа на основе метода k ближайших соседей для n вершин требуется <math>O(n log(n))</math> операций <ref>J.H. Friedman, J.L. Bentley, and R.A. Finkel. An algorithm for ﬁnding best matches in logarithmic expected time. ACM Transactions on Mathematical Software, 3:209–226, 1977.</ref>; для наборов данных большой размерности эта величина составляет <math>O(n^2)</math> операций <ref>S. Berchtold, C. Bohm, D. Keim, and H.-P. Kriegel. Cost model for nearest neighbor search in high dimensional data space. In Proc. of Symposium on Principles of Database Systems, Tucson, Arizona, 1997.</ref>;

2) Для выделения множества сравнительно малых связных подграфов требуется <math>nm</math> операций, где <math>m</math> - количество подграфов, полученных на втором этапе алгоритма;

3) Формирование набора кластеров, на основе множества подграфов, полученных на предыдущем этапе, требует <math>m^2log(m)</math> операций.

Итого, для n вершин получаем последовательную сложность <math>O(n log(n)+nm+m^2log(m))</math>.

== Информационный граф ==
[[File:СК.png]]

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

Первый этап работы алгоритма можно распределить между <math>n</math> процессами. На вход каждому процессу подается своя вершина, далее происходит процедура поиска <math>k</math> ближайших соседей. Параллельная сложность составляет <math>O(n)</math>.

Второй и третий этапы можно распараллелить частично.

Второй этап распараллеливается путем подачи на вход свободному процессу очередного подграфа для разделения. Число итераций оценивается в <math>O(n log(n))</math>.

Третий этап делится на расчет показателей схожести и соединение подграфов в кластеры. Процесс расчета показателей можно распараллелить, подавая каждому процессу на вход пару подграфов. Сложность этого процесса оценивается как <math>m log(m)</math>. Соединение подграфов в кластеры выполняется последовательно, сложность процесса составляет <math>m^2 log(m)</math>

Таким образом получаем общую параллельную сложность алгоритма: <math>O(n+ n log(n) + m^2 log (m) + m log(m))</math>

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

1. Симметрическая матрица <math>A</math> расстояний между элементами данных размера <math>n\times n</math> с нулями на главной диагонали (<math>a_{ii}= 0, i = 1, \ldots, N</math>).

2. <math>k</math> - количество ближайших соседей для вершин (рекомендуемое значение <math>k</math> от 5 до 20 в зависимости от количества анализируемых объектов).

3. <math>l</math> - наименьшее число вершин, которое может содержать наибольший подкластер на 2-м этапе . Величина этого параметра варьируется от 1 до 5 % от общего числа объектов.

'''Объём входных данных'''

<math>\frac{n (n - 1)}{2}</math> (в силу симметричности и нулевой главной диагонали достаточно хранить только над/поддиагональные элементы).

'''Выходные данные'''

Вектор из <math>n</math> чисел <math>u_{1}, u_{2}, \ldots, u_{N}</math>, где <math>u_{i}</math> - целое число, соответствующее кластеру <math>i</math>-го объекта.

'''Объём выходных данных'''

<math>n</math>

== Свойства алгоритма ==
Соотношение последовательной и параллельной сложности на первом этапе является ''линейным'' для больших наборов данных и логарифмическим для n вершин. На втором этапе сложно оценить это соотношение - оно сильно зависит от параметров <math>k</math> и <math>l</math>. На третьем этапе соотношение равно <math>O(1)</math>;

Оценка ''вычислительной мощности'' выглядит следующим образом:

<math>O(1)</math> для 1-го этапа;

<math>O(\frac{nm}{n^2+m^2})</math> для 2-го этапа;

<math>O(\frac{m^2log(m)}{m^2+n})</math> для 3-го этапа;

Алгоритм является ''недетерминированным''. Хотя 1-й этап детерминирован, на 2-ом этапе могут быть найдены различные разбиения на подграфы, что повлияет и на итоговый результат работы алгоритма.

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

Масштабируемость исследовалась на основе работы, презентующей пробную версию параллельной реализации алгоритма для различного числа потоков<ref>http://research.ijcaonline.org/volume79/number8/pxc3891600.pdf</ref>.
График показывает, что эффективность и скорость работы алгоритма растут с увеличением объема входных данных. Однако, в упомянутой выше работе отмечается, что эффективность алгоритма падает с ростом количества потоков.

[[File:Масштабирование.png|700px|center]]

== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Последовательная реализация алгоритма доступна по ссылке <ref>http://read.pudn.com/downloads36/sourcecode/math/115779/chameleon/chameleon.c__.htm</ref>.

CHAMELEON можно реализовать с использованием графовых библиотек METIS <ref>http://glaros.dtc.umn.edu/gkhome/metis/metis/overview
</ref>, hMETIS <ref>http://glaros.dtc.umn.edu/gkhome/metis/hmetis/overview</ref> и RANN <ref>https://cran.r-project.org/web/packages/RANN/index.html</ref>.

Существует исследование, связанное с реализацией CHAMELEON посредством технологии OpenMP, оно было рассмотрено в пункте 2.4.

Параллельных реализаций алгоритма CHAMELEON не найдено.

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

Участник:ЕкатеринаКозырева/Алгоритм динамической иерархической кластеризации CHAMELEON

2016-11-20T15:24:07Z

ЕкатеринаКозырева: /* Масштабируемость алгоритма и его реализации */

{{algorithm
| name = Алгоритм динамической иерархической кластеризации CHAMELEON
| serial_complexity = <math>O(nm + n log n + m^2 log m)</math>
| input_data = <math>\frac{n (n - 1)}{2}</math>
| output_data = <math>n</math>
| pf_height = <math>O(n+ n log(n) + m^2 log (m) + m log(m))</math>
| pf_width = <math>O(n)</math>
}}

Автор описания [[Участник:ЕкатеринаКозырева|Е.А.Козырева]]
= Свойства и структура алгоритмов =

== Общее описание алгоритма ==
Алгоритм CHAMELEON был предложен в 1999 году тремя учеными из университета Миннесоты – George Karypis, Eui-Hong (Sam) Han и Vipin Kumar<ref>George Karypis, Eui-Hong (Sam) Han и Vipin Kumar, «Chameleon: Hierarchical Clustering Using Dynamic Modeling», 1999.</ref>.

Предназначен для решения задач кластеризации. Кластеризация (или кластерный анализ) — это задача разбиения множества объектов на группы, называемые кластерами. Внутри каждой группы должны оказаться «похожие» объекты, а объекты разных группы должны быть как можно более отличны.

CHAMELEON - это агломеративный иерархический алгоритм кластеризации, ключевой особенностью которого является то, что он учитывает и взаимную связность, и сходство при определении наиболее похожей пары подкластеров, основываясь на динамической модели. Это означает, что в процессе кластеризации два кластера объединяются, только если их относительная взаимная связность и относительное взаимное сходство являются высокими по отношению к внутренней взаимосвязанности кластеров и близости элементов внутри кластеров. Кроме того, CHAMELEON использует подход для моделирования степени взаимосвязанности и близости между каждой парой кластеров, который учитывает внутренние характеристики самих кластеров. Таким образом, он может автоматически адаптироваться к внутренним характеристикам объединяемых кластеров.

CHAMELEON находит кластеры в наборе данных с помощью трехфазного алгоритма. На первой фазе происходит построение графа, путём добавления рёбер по принципу k ближайших соседей. На второй фазе CHAMELEON группирует полученные элементы в множество относительно небольших подграфов. Во время третьей фазы применяется агломеративный иерархический алгоритм кластеризации, с помощью которого находятся естесственные кластеры путем многократного объединения подграфов, полученных на прошлом этапе.

[[File:Chameleon.png|1000px|thumb|center|Рисунок 1. Общая структура алгоритма CHAMELEON]]

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

''Исходные данные'':

* Множество из n точек <math>V= {v_{ij}}</math> в метрическом пространстве, которое задано симметрической матрицей расстояний <math>A</math> размера <math>n\times n</math>.
* <math>k</math> - количество ближайших соседей для вершин, <math>k \in N, k \leq n</math>.
* <math>l</math> - наименьшее число вершин, которое может содержать наибольший подграф на 2-м этапе, <math>l \in N, l \leq n</math>.

''Обозначения'':

* <math>G = (V, E)</math> - граф, полученный путём соединения каждой точки с её <math>k</math> ближайшими соседями.

* <math>K= \{K_{i}\}</math> - разбиение множества <math>V</math> на набор попарно непересекающихся связных подмножеств, полученное в результате выполнения второй фазы алгоритма.

* <math>G_{2} = (K, E_{2})</math> - взвешенный граф, вершинами которого являются получившиеся подграфы, а ребрами - количество ребер исходного графа, соединяющих соответствующие подграфы.

* <math>C = \{C_{i}\}</math> - итоговое разбиение множества вершин графа <math>G_{2}</math> на набор кластеров.

''Вспомогательные понятия''

*<math>EC_{(C_{i},C_{j})}</math> - абсолютная взаимная связность пары кластеров <math>C_{i}, C{j}</math>. Определяется как сумма весов ребер, соединяющих вершины, принадлежащие <math>C{i}</math> c вершинами из <math>C{j}</math>. Внутренняя связность <math>EC_{(C_{i},C_{i})}</math> вычисляется как сумма ребер, входящих в разделитель, разбивающий <math>C{i}</math> на два равных подграфа.

*<math>RI_{(C_{i},C_{j})} = \frac{|EC_{(C_{i},C_{j})}|}{(|EC_{C_{i}}|+|EC_{C_{j}}|)/2}</math> - относительная взаимная связность пары кластеров <math>C_{i}, C{j}</math>

*<math>S_{EC_{(C_{i},C_{j})}}</math> - абсолютное взаимное сходство пары кластеров <math>C_{i}, C{j}</math>. Подсчитывается как среднее сходство между соединенными вершинами, принадлежащими <math>C{i}</math> и <math>C{j}</math> соответственно. Соединения обусловлены разбиением общего графа, полученного на первом этапе алгоритма.

*<math> RC_{(C_{i},C_{j})}= \frac{S_{EC_{(C_{i},C_{j})}}}{\frac{|C_{i}|}{|C_{i}+C_{j}|}*S_{EC_{(C_{i})}}+\frac{|C_{i}|}{|C_{i}+C_{j}|}*S_{EC_{(C_{j})}}}</math> - относительное взаимное сходство пары кластеров <math>C_{i}, C{j}</math>. Определяется как абсолютное сходство между этой парой кластеров, нормализованное с учетом их внутреннего сходства<ref>http://studopedia.ru/7_41934_algoritm-dinamicheskoy-ierarhicheskoy-klasterizatsii-CHAMELEON.html</ref>.

'''Первый этап'''

На первом этапе, согласно графо-ориентированному подходу, происходит построение графа <math>G = (V, E)</math> на матрице сходства объектов по принципу k ближайших соседей. Две вершины такого графа соединяет ребро, если объект, соответствующий любой из этих вершин попадает в число k наиболее близких объектов для объекта, соответствующего другой вершине из данной пары.
[[Файл:Снимок chameleon 2.png|2000px|thumb|Рисунок 2. Объекты в пространстве - слева, граф по принципу 1-го ближайшего соседа - по центру, граф по принципу 3-х ближайших соседей - справа ]]

'''Второй этап'''

Алгоритм разделяет полученный граф на множество сравнительно малых подграфов <math>K= \{K_{i}\}</math>. Разделение происходит последовательно. На каждом шаге выбирается подграф, содержащий наибольшее число вершин. Этот граф разделяется на два подграфа так, что разделитель ребер графа минимален и каждый из получаемых подграфов содержит не менее 25 % вершин исходного графа. Процесс разделения останавливается, когда наибольший подграф содержит меньше некоторого заданного числа вершин. Обычно величина этого параметра задается равной значению от 1 до 5 % от числа объектов. Полученное множество связных графов считается множеством начальных кластеров, на котором требуется провести последовательное иерархическое объединение.

'''Третий этап'''

Третий этап заключается в итеративном преобразовании множества подграфов <math>K= \{K_{i}\}</math> в множество кластеров <math>C = \{C_{i}\}</math>. Алгоритм осуществляет агломеративную иерархическую кластеризацию на основании показателей <math>EC_{(C_{i},C_{j})}</math>, <math>S_{EC_{(C_{i},C_{j})}}</math>, <math>RI_{(C_{i},C_{j})} </math>, <math> RC_{(C_{i},C_{j})}</math>. Существует две стратегии анализа показателей сходства. Первая подразумевает наличие некоторых пороговых значений <math>T_{RI}</math> и <math>T_{RC}</math>. В соответствии с этой стратегией, алгоритм для каждого кластера <math>C_{i}</math> проверяет, отвечают ли смежные (наиболее близкие) ему кластеры условиям:

*<math>RI_{(C_{i},C_{j})} \geqslant T_{RI}</math>

*<math>RC_{(C_{i},C_{j})} \geqslant T_{RC}</math>

Если более одного смежного кластера отвечает этим условиям, то алгоритм выбирает для объединения наиболее связный кластер (граф), то есть такой кластер <math>C_{j}</math>, с которым у кластера <math>C_{i}</math> получается наибольшая абсолютная взаимная связность. По завершению прохода по всем кластерам, созданные таким образом пары объединяются. Параметры <math>T_{RI}</math> и <math>T_{RC}</math> могут использоваться для изменения характеристик получаемых кластеров.

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

<math>RI_{(C_{i},C_{j})}*RC_{(C_{i},C_{j})}^\alpha</math>,

где <math>\alpha</math> выбирается пользователем. Если <math>\alpha > 1 </math>, то алгоритм придает большее значение относительному взаимному сходству, а если <math>\alpha < 1 </math>, то большее значение имеет относительная взаимная связность.

''Вычисляемые данные'':

<math>U = (u_1, u_2, ..., u_n)</math> - n-мерный вектор, где <math>u_i \in N_{[C]}</math> - порядковый номер кластера, к которому принадлежит вершина i исходного множества V.

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

Алгоритм имеет три вычислительных ядра, по одному на каждый этап.

На первом этапе вычислительным ядром является процесс нахождения <math>k</math> ближайших соседей для каждой вершины, который заключается в анализе матрицы расстояний.

На втором этапе вычислительным ядром является процесс поиска подходящего разбиения очередного подграфа на два графа с минимизацией разделителя ребер графа.

На третьем этапе вычислительным ядром является расчет величин <math>EC_{(C_{i},C_{j})}</math>, <math>S_{EC_{(C_{i},C_{j})}}</math>, <math>RI_{(C_{i},C_{j})} </math>, <math> RC_{(C_{i},C_{j})}</math> для каждой пары смежных кластеров.

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

Как уже рассказывалось ранее, алгоритм включает в себя три основных этапа, каждый из которых, по сути, является отдельным алгоритмом. Этапы выполняются последовательно относительно друг друга.

Макрооперация на первом этапе - процедура нахождения <math>k</math> ближайших соседей, на втором - процедура разбиения наибольшего подграфа на два графа, на третьем - процедура вычисления показателей сходства, на основе которых принимается решение о слиянии подграфов в кластер.

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

'''Первый этап'''
<source lang="cpp">
int n; //количество вершин
int k; //количество соседей
int A[n][n] //матрица расстояний
int D[k] //массив вершин-соседей
int E[n][n] //матрица ребер графа <math>G_{2} = (K, E_{2})</math>
for i=1 to n-1 do
{
for j=i+1 to n do
{
//заполняем массив вершин-соседей вставляя новые вершины, если они ближе, чем самая далекая из массива.
}
for j=0 to k do
{
//для каждой вершины соседа заполняем соответствующую ячейку из матрицы E[n][n] единицей
}

}
</source>

'''Второй этап'''

1. Все связные подграфы в отсортированном порядке помещаются в список;
2. Берем наибольший элемент списка, вычисляем количество его вершин. Если число вершин > l, то идем в пункт 3. Иначе в пункт 5;
3. Разбиваем подграф на два подграфа таким образом, чтобы разделитель ребер графа был минимален и каждый из получаемых подграфов содержал не менее 25 % вершин исходного графа;
4. Добавляем полученные элементы в список подграфов таким образом, чтобы список оставался отсортированным. Идем в пункт 2;
5. Нашли искомое множество подграфов math>K = \{K_{i}\}</math>;
6. Создаем и заполняем матрицу матрицу расстояний для графа <math>G_{2} = (K, E_{2})</math>. Получаем искомый набор рёбер <math>E_{2}</math>.

'''Третий этап'''

1. Заводим два массива: а) массив кластеров C, полученных на предыдущем этапе, б) массив объединений кластеров F, которые мы будем получать на этом этапе;
2. Берем следующий кластер <math>C_{i}</math> (на первом шаге - первый). Если все кластеры просмотрены, идем в пункт 6;
3. Берем следующий кластер <math>C_{j}, i<>j</math>. Если все кластеры просмотрены, то идем в пункт 2;
4. Проверяем смежность <math>C_{i}</math> и <math>C_{j}</math>. Если не смежны, то возвращаемся в пункт 3. Если смежны, идем в пункт 5;
5. Рассчитываем показатели <math>RI_{(C_{i},C_{j})}</math> и <math> RC_{(C_{i},C_{j})}</math>. Проверяем, удовлетворяют ли найденные значения условиям:
*<math>RI_{(C_{i},C_{j})} \geqslant T_{RI}</math>
*<math>RC_{(C_{i},C_{j})} \geqslant T_{RC}</math>
Если нет, то идем в пункт 3. Иначе если смежность пары кластеров выше, чем у предыдущих найденных, то <math>F_{i}=j</math>. Идем в пункт 3;
6. Если в списке F есть хотя бы одна пара кластеров для слияния, то выполняем слияние, обновляем массив кластеров и массив объединений кластеров. Идем в пункт 2.

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

1) Для построения графа на основе метода k ближайших соседей для n вершин требуется <math>O(n log(n))</math> операций <ref>J.H. Friedman, J.L. Bentley, and R.A. Finkel. An algorithm for ﬁnding best matches in logarithmic expected time. ACM Transactions on Mathematical Software, 3:209–226, 1977.</ref>; для наборов данных большой размерности эта величина составляет <math>O(n^2)</math> операций <ref>S. Berchtold, C. Bohm, D. Keim, and H.-P. Kriegel. Cost model for nearest neighbor search in high dimensional data space. In Proc. of Symposium on Principles of Database Systems, Tucson, Arizona, 1997.</ref>;

2) Для выделения множества сравнительно малых связных подграфов требуется <math>nm</math> операций, где <math>m</math> - количество подграфов, полученных на втором этапе алгоритма;

3) Формирование набора кластеров, на основе множества подграфов, полученных на предыдущем этапе, требует <math>m^2log(m)</math> операций.

Итого, для n вершин получаем последовательную сложность <math>O(n log(n)+nm+m^2log(m))</math>.

== Информационный граф ==
[[File:СК.png]]

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

Первый этап работы алгоритма можно распределить между <math>n</math> процессами. На вход каждому процессу подается своя вершина, далее происходит процедура поиска <math>k</math> ближайших соседей. Параллельная сложность составляет <math>O(n)</math>.

Второй и третий этапы можно распараллелить частично.

Второй этап распараллеливается путем подачи на вход свободному процессу очередного подграфа для разделения. Число итераций оценивается в <math>O(n log(n))</math>.

Третий этап делится на расчет показателей схожести и соединение подграфов в кластеры. Процесс расчета показателей можно распараллелить, подавая каждому процессу на вход пару подграфов. Сложность этого процесса оценивается как <math>m log(m)</math>. Соединение подграфов в кластеры выполняется последовательно, сложность процесса составляет <math>m^2 log(m)</math>

Таким образом получаем общую параллельную сложность алгоритма: <math>O(n+ n log(n) + m^2 log (m) + m log(m))</math>

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

1. Симметрическая матрица <math>A</math> расстояний между элементами данных размера <math>n\times n</math> с нулями на главной диагонали (<math>a_{ii}= 0, i = 1, \ldots, N</math>).

2. <math>k</math> - количество ближайших соседей для вершин (рекомендуемое значение <math>k</math> от 5 до 20 в зависимости от количества анализируемых объектов).

3. <math>l</math> - наименьшее число вершин, которое может содержать наибольший подкластер на 2-м этапе . Величина этого параметра варьируется от 1 до 5 % от общего числа объектов.

'''Объём входных данных'''

<math>\frac{n (n - 1)}{2}</math> (в силу симметричности и нулевой главной диагонали достаточно хранить только над/поддиагональные элементы).

'''Выходные данные'''

Вектор из <math>n</math> чисел <math>u_{1}, u_{2}, \ldots, u_{N}</math>, где <math>u_{i}</math> - целое число, соответствующее кластеру <math>i</math>-го объекта.

'''Объём выходных данных'''

<math>n</math>

== Свойства алгоритма ==
Соотношение последовательной и параллельной сложности на первом этапе является ''линейным'' для больших наборов данных и логарифмическим для n вершин. На втором этапе сложно оценить это соотношение - оно сильно зависит от параметров <math>k</math> и <math>l</math>. На третьем этапе соотношение равно <math>O(1)</math>;

Оценка ''вычислительной мощности'' выглядит следующим образом:

<math>O(1)</math> для 1-го этапа;

<math>O(\frac{nm}{n^2+m^2})</math> для 2-го этапа;

<math>O(\frac{m^2log(m)}{m^2+n})</math> для 3-го этапа;

Алгоритм является ''недетерминированным''. Хотя 1-й этап детерминирован, на 2-ом этапе могут быть найдены различные разбиения на подграфы, что повлияет и на итоговый результат работы алгоритма.

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

Масштабируемость исследовалась на основе работы, презентующей пробную версию параллельной реализации алгоритма для различного числа потоков<ref>http://research.ijcaonline.org/volume79/number8/pxc3891600.pdf</ref>.
График показывает, что эффективность и скорость работы алгоритма растут с увеличением объема входных данных. Однако, в упомянутой выше работе отмечается, что эффективность алгоритма падает с ростом количества потоков.

[[File:Масштабирование.png|700px|center]]

== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Последовательная реализация алгоритма доступна по ссылке <ref>http://read.pudn.com/downloads36/sourcecode/math/115779/chameleon/chameleon.c__.htm</ref>.

CHAMELEON можно реализовать с использованием графовых библиотек METIS <ref>http://glaros.dtc.umn.edu/gkhome/metis/metis/overview
</ref>, hMETIS <ref>http://glaros.dtc.umn.edu/gkhome/metis/hmetis/overview</ref> и RANN <ref>https://cran.r-project.org/web/packages/RANN/index.html</ref>.

Параллельных реализаций алгоритма CHAMELEON не найдено.

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

Участник:ЕкатеринаКозырева/Алгоритм динамической иерархической кластеризации CHAMELEON

2016-11-20T15:23:12Z

ЕкатеринаКозырева: /* Существующие реализации алгоритма */

{{algorithm
| name = Алгоритм динамической иерархической кластеризации CHAMELEON
| serial_complexity = <math>O(nm + n log n + m^2 log m)</math>
| input_data = <math>\frac{n (n - 1)}{2}</math>
| output_data = <math>n</math>
| pf_height = <math>O(n+ n log(n) + m^2 log (m) + m log(m))</math>
| pf_width = <math>O(n)</math>
}}

Автор описания [[Участник:ЕкатеринаКозырева|Е.А.Козырева]]
= Свойства и структура алгоритмов =

== Общее описание алгоритма ==
Алгоритм CHAMELEON был предложен в 1999 году тремя учеными из университета Миннесоты – George Karypis, Eui-Hong (Sam) Han и Vipin Kumar<ref>George Karypis, Eui-Hong (Sam) Han и Vipin Kumar, «Chameleon: Hierarchical Clustering Using Dynamic Modeling», 1999.</ref>.

Предназначен для решения задач кластеризации. Кластеризация (или кластерный анализ) — это задача разбиения множества объектов на группы, называемые кластерами. Внутри каждой группы должны оказаться «похожие» объекты, а объекты разных группы должны быть как можно более отличны.

CHAMELEON - это агломеративный иерархический алгоритм кластеризации, ключевой особенностью которого является то, что он учитывает и взаимную связность, и сходство при определении наиболее похожей пары подкластеров, основываясь на динамической модели. Это означает, что в процессе кластеризации два кластера объединяются, только если их относительная взаимная связность и относительное взаимное сходство являются высокими по отношению к внутренней взаимосвязанности кластеров и близости элементов внутри кластеров. Кроме того, CHAMELEON использует подход для моделирования степени взаимосвязанности и близости между каждой парой кластеров, который учитывает внутренние характеристики самих кластеров. Таким образом, он может автоматически адаптироваться к внутренним характеристикам объединяемых кластеров.

CHAMELEON находит кластеры в наборе данных с помощью трехфазного алгоритма. На первой фазе происходит построение графа, путём добавления рёбер по принципу k ближайших соседей. На второй фазе CHAMELEON группирует полученные элементы в множество относительно небольших подграфов. Во время третьей фазы применяется агломеративный иерархический алгоритм кластеризации, с помощью которого находятся естесственные кластеры путем многократного объединения подграфов, полученных на прошлом этапе.

[[File:Chameleon.png|1000px|thumb|center|Рисунок 1. Общая структура алгоритма CHAMELEON]]

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

''Исходные данные'':

* Множество из n точек <math>V= {v_{ij}}</math> в метрическом пространстве, которое задано симметрической матрицей расстояний <math>A</math> размера <math>n\times n</math>.
* <math>k</math> - количество ближайших соседей для вершин, <math>k \in N, k \leq n</math>.
* <math>l</math> - наименьшее число вершин, которое может содержать наибольший подграф на 2-м этапе, <math>l \in N, l \leq n</math>.

''Обозначения'':

* <math>G = (V, E)</math> - граф, полученный путём соединения каждой точки с её <math>k</math> ближайшими соседями.

* <math>K= \{K_{i}\}</math> - разбиение множества <math>V</math> на набор попарно непересекающихся связных подмножеств, полученное в результате выполнения второй фазы алгоритма.

* <math>G_{2} = (K, E_{2})</math> - взвешенный граф, вершинами которого являются получившиеся подграфы, а ребрами - количество ребер исходного графа, соединяющих соответствующие подграфы.

* <math>C = \{C_{i}\}</math> - итоговое разбиение множества вершин графа <math>G_{2}</math> на набор кластеров.

''Вспомогательные понятия''

*<math>EC_{(C_{i},C_{j})}</math> - абсолютная взаимная связность пары кластеров <math>C_{i}, C{j}</math>. Определяется как сумма весов ребер, соединяющих вершины, принадлежащие <math>C{i}</math> c вершинами из <math>C{j}</math>. Внутренняя связность <math>EC_{(C_{i},C_{i})}</math> вычисляется как сумма ребер, входящих в разделитель, разбивающий <math>C{i}</math> на два равных подграфа.

*<math>RI_{(C_{i},C_{j})} = \frac{|EC_{(C_{i},C_{j})}|}{(|EC_{C_{i}}|+|EC_{C_{j}}|)/2}</math> - относительная взаимная связность пары кластеров <math>C_{i}, C{j}</math>

*<math>S_{EC_{(C_{i},C_{j})}}</math> - абсолютное взаимное сходство пары кластеров <math>C_{i}, C{j}</math>. Подсчитывается как среднее сходство между соединенными вершинами, принадлежащими <math>C{i}</math> и <math>C{j}</math> соответственно. Соединения обусловлены разбиением общего графа, полученного на первом этапе алгоритма.

*<math> RC_{(C_{i},C_{j})}= \frac{S_{EC_{(C_{i},C_{j})}}}{\frac{|C_{i}|}{|C_{i}+C_{j}|}*S_{EC_{(C_{i})}}+\frac{|C_{i}|}{|C_{i}+C_{j}|}*S_{EC_{(C_{j})}}}</math> - относительное взаимное сходство пары кластеров <math>C_{i}, C{j}</math>. Определяется как абсолютное сходство между этой парой кластеров, нормализованное с учетом их внутреннего сходства<ref>http://studopedia.ru/7_41934_algoritm-dinamicheskoy-ierarhicheskoy-klasterizatsii-CHAMELEON.html</ref>.

'''Первый этап'''

На первом этапе, согласно графо-ориентированному подходу, происходит построение графа <math>G = (V, E)</math> на матрице сходства объектов по принципу k ближайших соседей. Две вершины такого графа соединяет ребро, если объект, соответствующий любой из этих вершин попадает в число k наиболее близких объектов для объекта, соответствующего другой вершине из данной пары.
[[Файл:Снимок chameleon 2.png|2000px|thumb|Рисунок 2. Объекты в пространстве - слева, граф по принципу 1-го ближайшего соседа - по центру, граф по принципу 3-х ближайших соседей - справа ]]

'''Второй этап'''

Алгоритм разделяет полученный граф на множество сравнительно малых подграфов <math>K= \{K_{i}\}</math>. Разделение происходит последовательно. На каждом шаге выбирается подграф, содержащий наибольшее число вершин. Этот граф разделяется на два подграфа так, что разделитель ребер графа минимален и каждый из получаемых подграфов содержит не менее 25 % вершин исходного графа. Процесс разделения останавливается, когда наибольший подграф содержит меньше некоторого заданного числа вершин. Обычно величина этого параметра задается равной значению от 1 до 5 % от числа объектов. Полученное множество связных графов считается множеством начальных кластеров, на котором требуется провести последовательное иерархическое объединение.

'''Третий этап'''

Третий этап заключается в итеративном преобразовании множества подграфов <math>K= \{K_{i}\}</math> в множество кластеров <math>C = \{C_{i}\}</math>. Алгоритм осуществляет агломеративную иерархическую кластеризацию на основании показателей <math>EC_{(C_{i},C_{j})}</math>, <math>S_{EC_{(C_{i},C_{j})}}</math>, <math>RI_{(C_{i},C_{j})} </math>, <math> RC_{(C_{i},C_{j})}</math>. Существует две стратегии анализа показателей сходства. Первая подразумевает наличие некоторых пороговых значений <math>T_{RI}</math> и <math>T_{RC}</math>. В соответствии с этой стратегией, алгоритм для каждого кластера <math>C_{i}</math> проверяет, отвечают ли смежные (наиболее близкие) ему кластеры условиям:

*<math>RI_{(C_{i},C_{j})} \geqslant T_{RI}</math>

*<math>RC_{(C_{i},C_{j})} \geqslant T_{RC}</math>

Если более одного смежного кластера отвечает этим условиям, то алгоритм выбирает для объединения наиболее связный кластер (граф), то есть такой кластер <math>C_{j}</math>, с которым у кластера <math>C_{i}</math> получается наибольшая абсолютная взаимная связность. По завершению прохода по всем кластерам, созданные таким образом пары объединяются. Параметры <math>T_{RI}</math> и <math>T_{RC}</math> могут использоваться для изменения характеристик получаемых кластеров.

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

<math>RI_{(C_{i},C_{j})}*RC_{(C_{i},C_{j})}^\alpha</math>,

где <math>\alpha</math> выбирается пользователем. Если <math>\alpha > 1 </math>, то алгоритм придает большее значение относительному взаимному сходству, а если <math>\alpha < 1 </math>, то большее значение имеет относительная взаимная связность.

''Вычисляемые данные'':

<math>U = (u_1, u_2, ..., u_n)</math> - n-мерный вектор, где <math>u_i \in N_{[C]}</math> - порядковый номер кластера, к которому принадлежит вершина i исходного множества V.

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

Алгоритм имеет три вычислительных ядра, по одному на каждый этап.

На первом этапе вычислительным ядром является процесс нахождения <math>k</math> ближайших соседей для каждой вершины, который заключается в анализе матрицы расстояний.

На втором этапе вычислительным ядром является процесс поиска подходящего разбиения очередного подграфа на два графа с минимизацией разделителя ребер графа.

На третьем этапе вычислительным ядром является расчет величин <math>EC_{(C_{i},C_{j})}</math>, <math>S_{EC_{(C_{i},C_{j})}}</math>, <math>RI_{(C_{i},C_{j})} </math>, <math> RC_{(C_{i},C_{j})}</math> для каждой пары смежных кластеров.

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

Как уже рассказывалось ранее, алгоритм включает в себя три основных этапа, каждый из которых, по сути, является отдельным алгоритмом. Этапы выполняются последовательно относительно друг друга.

Макрооперация на первом этапе - процедура нахождения <math>k</math> ближайших соседей, на втором - процедура разбиения наибольшего подграфа на два графа, на третьем - процедура вычисления показателей сходства, на основе которых принимается решение о слиянии подграфов в кластер.

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

'''Первый этап'''
<source lang="cpp">
int n; //количество вершин
int k; //количество соседей
int A[n][n] //матрица расстояний
int D[k] //массив вершин-соседей
int E[n][n] //матрица ребер графа <math>G_{2} = (K, E_{2})</math>
for i=1 to n-1 do
{
for j=i+1 to n do
{
//заполняем массив вершин-соседей вставляя новые вершины, если они ближе, чем самая далекая из массива.
}
for j=0 to k do
{
//для каждой вершины соседа заполняем соответствующую ячейку из матрицы E[n][n] единицей
}

}
</source>

'''Второй этап'''

1. Все связные подграфы в отсортированном порядке помещаются в список;
2. Берем наибольший элемент списка, вычисляем количество его вершин. Если число вершин > l, то идем в пункт 3. Иначе в пункт 5;
3. Разбиваем подграф на два подграфа таким образом, чтобы разделитель ребер графа был минимален и каждый из получаемых подграфов содержал не менее 25 % вершин исходного графа;
4. Добавляем полученные элементы в список подграфов таким образом, чтобы список оставался отсортированным. Идем в пункт 2;
5. Нашли искомое множество подграфов math>K = \{K_{i}\}</math>;
6. Создаем и заполняем матрицу матрицу расстояний для графа <math>G_{2} = (K, E_{2})</math>. Получаем искомый набор рёбер <math>E_{2}</math>.

'''Третий этап'''

1. Заводим два массива: а) массив кластеров C, полученных на предыдущем этапе, б) массив объединений кластеров F, которые мы будем получать на этом этапе;
2. Берем следующий кластер <math>C_{i}</math> (на первом шаге - первый). Если все кластеры просмотрены, идем в пункт 6;
3. Берем следующий кластер <math>C_{j}, i<>j</math>. Если все кластеры просмотрены, то идем в пункт 2;
4. Проверяем смежность <math>C_{i}</math> и <math>C_{j}</math>. Если не смежны, то возвращаемся в пункт 3. Если смежны, идем в пункт 5;
5. Рассчитываем показатели <math>RI_{(C_{i},C_{j})}</math> и <math> RC_{(C_{i},C_{j})}</math>. Проверяем, удовлетворяют ли найденные значения условиям:
*<math>RI_{(C_{i},C_{j})} \geqslant T_{RI}</math>
*<math>RC_{(C_{i},C_{j})} \geqslant T_{RC}</math>
Если нет, то идем в пункт 3. Иначе если смежность пары кластеров выше, чем у предыдущих найденных, то <math>F_{i}=j</math>. Идем в пункт 3;
6. Если в списке F есть хотя бы одна пара кластеров для слияния, то выполняем слияние, обновляем массив кластеров и массив объединений кластеров. Идем в пункт 2.

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

1) Для построения графа на основе метода k ближайших соседей для n вершин требуется <math>O(n log(n))</math> операций <ref>J.H. Friedman, J.L. Bentley, and R.A. Finkel. An algorithm for ﬁnding best matches in logarithmic expected time. ACM Transactions on Mathematical Software, 3:209–226, 1977.</ref>; для наборов данных большой размерности эта величина составляет <math>O(n^2)</math> операций <ref>S. Berchtold, C. Bohm, D. Keim, and H.-P. Kriegel. Cost model for nearest neighbor search in high dimensional data space. In Proc. of Symposium on Principles of Database Systems, Tucson, Arizona, 1997.</ref>;

2) Для выделения множества сравнительно малых связных подграфов требуется <math>nm</math> операций, где <math>m</math> - количество подграфов, полученных на втором этапе алгоритма;

3) Формирование набора кластеров, на основе множества подграфов, полученных на предыдущем этапе, требует <math>m^2log(m)</math> операций.

Итого, для n вершин получаем последовательную сложность <math>O(n log(n)+nm+m^2log(m))</math>.

== Информационный граф ==
[[File:СК.png]]

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

Первый этап работы алгоритма можно распределить между <math>n</math> процессами. На вход каждому процессу подается своя вершина, далее происходит процедура поиска <math>k</math> ближайших соседей. Параллельная сложность составляет <math>O(n)</math>.

Второй и третий этапы можно распараллелить частично.

Второй этап распараллеливается путем подачи на вход свободному процессу очередного подграфа для разделения. Число итераций оценивается в <math>O(n log(n))</math>.

Третий этап делится на расчет показателей схожести и соединение подграфов в кластеры. Процесс расчета показателей можно распараллелить, подавая каждому процессу на вход пару подграфов. Сложность этого процесса оценивается как <math>m log(m)</math>. Соединение подграфов в кластеры выполняется последовательно, сложность процесса составляет <math>m^2 log(m)</math>

Таким образом получаем общую параллельную сложность алгоритма: <math>O(n+ n log(n) + m^2 log (m) + m log(m))</math>

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

1. Симметрическая матрица <math>A</math> расстояний между элементами данных размера <math>n\times n</math> с нулями на главной диагонали (<math>a_{ii}= 0, i = 1, \ldots, N</math>).

2. <math>k</math> - количество ближайших соседей для вершин (рекомендуемое значение <math>k</math> от 5 до 20 в зависимости от количества анализируемых объектов).

3. <math>l</math> - наименьшее число вершин, которое может содержать наибольший подкластер на 2-м этапе . Величина этого параметра варьируется от 1 до 5 % от общего числа объектов.

'''Объём входных данных'''

<math>\frac{n (n - 1)}{2}</math> (в силу симметричности и нулевой главной диагонали достаточно хранить только над/поддиагональные элементы).

'''Выходные данные'''

Вектор из <math>n</math> чисел <math>u_{1}, u_{2}, \ldots, u_{N}</math>, где <math>u_{i}</math> - целое число, соответствующее кластеру <math>i</math>-го объекта.

'''Объём выходных данных'''

<math>n</math>

== Свойства алгоритма ==
Соотношение последовательной и параллельной сложности на первом этапе является ''линейным'' для больших наборов данных и логарифмическим для n вершин. На втором этапе сложно оценить это соотношение - оно сильно зависит от параметров <math>k</math> и <math>l</math>. На третьем этапе соотношение равно <math>O(1)</math>;

Оценка ''вычислительной мощности'' выглядит следующим образом:

<math>O(1)</math> для 1-го этапа;

<math>O(\frac{nm}{n^2+m^2})</math> для 2-го этапа;

<math>O(\frac{m^2log(m)}{m^2+n})</math> для 3-го этапа;

Алгоритм является ''недетерминированным''. Хотя 1-й этап детерминирован, на 2-ом этапе могут быть найдены различные разбиения на подграфы, что повлияет и на итоговый результат работы алгоритма.

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

Масштабируемость исследовалась на основе работы, презентующей пробную версию параллельной реализации алгоритма для различного числа потоков.
График показывает, что эффективность и скорость работы алгоритма растут с увеличением объема входных данных. Однако, в упомянутой выше работе отмечается, что эффективность алгоритма падает с ростом количества потоков.

[[File:Масштабирование.png|700px|center]]

== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Последовательная реализация алгоритма доступна по ссылке <ref>http://read.pudn.com/downloads36/sourcecode/math/115779/chameleon/chameleon.c__.htm</ref>.

CHAMELEON можно реализовать с использованием графовых библиотек METIS <ref>http://glaros.dtc.umn.edu/gkhome/metis/metis/overview
</ref>, hMETIS <ref>http://glaros.dtc.umn.edu/gkhome/metis/hmetis/overview</ref> и RANN <ref>https://cran.r-project.org/web/packages/RANN/index.html</ref>.

Параллельных реализаций алгоритма CHAMELEON не найдено.

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

Участник:ЕкатеринаКозырева/Алгоритм динамической иерархической кластеризации CHAMELEON

2016-11-20T15:22:23Z

ЕкатеринаКозырева: /* Масштабируемость алгоритма и его реализации */

{{algorithm
| name = Алгоритм динамической иерархической кластеризации CHAMELEON
| serial_complexity = <math>O(nm + n log n + m^2 log m)</math>
| input_data = <math>\frac{n (n - 1)}{2}</math>
| output_data = <math>n</math>
| pf_height = <math>O(n+ n log(n) + m^2 log (m) + m log(m))</math>
| pf_width = <math>O(n)</math>
}}

Автор описания [[Участник:ЕкатеринаКозырева|Е.А.Козырева]]
= Свойства и структура алгоритмов =

== Общее описание алгоритма ==
Алгоритм CHAMELEON был предложен в 1999 году тремя учеными из университета Миннесоты – George Karypis, Eui-Hong (Sam) Han и Vipin Kumar<ref>George Karypis, Eui-Hong (Sam) Han и Vipin Kumar, «Chameleon: Hierarchical Clustering Using Dynamic Modeling», 1999.</ref>.

Предназначен для решения задач кластеризации. Кластеризация (или кластерный анализ) — это задача разбиения множества объектов на группы, называемые кластерами. Внутри каждой группы должны оказаться «похожие» объекты, а объекты разных группы должны быть как можно более отличны.

CHAMELEON - это агломеративный иерархический алгоритм кластеризации, ключевой особенностью которого является то, что он учитывает и взаимную связность, и сходство при определении наиболее похожей пары подкластеров, основываясь на динамической модели. Это означает, что в процессе кластеризации два кластера объединяются, только если их относительная взаимная связность и относительное взаимное сходство являются высокими по отношению к внутренней взаимосвязанности кластеров и близости элементов внутри кластеров. Кроме того, CHAMELEON использует подход для моделирования степени взаимосвязанности и близости между каждой парой кластеров, который учитывает внутренние характеристики самих кластеров. Таким образом, он может автоматически адаптироваться к внутренним характеристикам объединяемых кластеров.

CHAMELEON находит кластеры в наборе данных с помощью трехфазного алгоритма. На первой фазе происходит построение графа, путём добавления рёбер по принципу k ближайших соседей. На второй фазе CHAMELEON группирует полученные элементы в множество относительно небольших подграфов. Во время третьей фазы применяется агломеративный иерархический алгоритм кластеризации, с помощью которого находятся естесственные кластеры путем многократного объединения подграфов, полученных на прошлом этапе.

[[File:Chameleon.png|1000px|thumb|center|Рисунок 1. Общая структура алгоритма CHAMELEON]]

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

''Исходные данные'':

* Множество из n точек <math>V= {v_{ij}}</math> в метрическом пространстве, которое задано симметрической матрицей расстояний <math>A</math> размера <math>n\times n</math>.
* <math>k</math> - количество ближайших соседей для вершин, <math>k \in N, k \leq n</math>.
* <math>l</math> - наименьшее число вершин, которое может содержать наибольший подграф на 2-м этапе, <math>l \in N, l \leq n</math>.

''Обозначения'':

* <math>G = (V, E)</math> - граф, полученный путём соединения каждой точки с её <math>k</math> ближайшими соседями.

* <math>K= \{K_{i}\}</math> - разбиение множества <math>V</math> на набор попарно непересекающихся связных подмножеств, полученное в результате выполнения второй фазы алгоритма.

* <math>G_{2} = (K, E_{2})</math> - взвешенный граф, вершинами которого являются получившиеся подграфы, а ребрами - количество ребер исходного графа, соединяющих соответствующие подграфы.

* <math>C = \{C_{i}\}</math> - итоговое разбиение множества вершин графа <math>G_{2}</math> на набор кластеров.

''Вспомогательные понятия''

*<math>EC_{(C_{i},C_{j})}</math> - абсолютная взаимная связность пары кластеров <math>C_{i}, C{j}</math>. Определяется как сумма весов ребер, соединяющих вершины, принадлежащие <math>C{i}</math> c вершинами из <math>C{j}</math>. Внутренняя связность <math>EC_{(C_{i},C_{i})}</math> вычисляется как сумма ребер, входящих в разделитель, разбивающий <math>C{i}</math> на два равных подграфа.

*<math>RI_{(C_{i},C_{j})} = \frac{|EC_{(C_{i},C_{j})}|}{(|EC_{C_{i}}|+|EC_{C_{j}}|)/2}</math> - относительная взаимная связность пары кластеров <math>C_{i}, C{j}</math>

*<math>S_{EC_{(C_{i},C_{j})}}</math> - абсолютное взаимное сходство пары кластеров <math>C_{i}, C{j}</math>. Подсчитывается как среднее сходство между соединенными вершинами, принадлежащими <math>C{i}</math> и <math>C{j}</math> соответственно. Соединения обусловлены разбиением общего графа, полученного на первом этапе алгоритма.

*<math> RC_{(C_{i},C_{j})}= \frac{S_{EC_{(C_{i},C_{j})}}}{\frac{|C_{i}|}{|C_{i}+C_{j}|}*S_{EC_{(C_{i})}}+\frac{|C_{i}|}{|C_{i}+C_{j}|}*S_{EC_{(C_{j})}}}</math> - относительное взаимное сходство пары кластеров <math>C_{i}, C{j}</math>. Определяется как абсолютное сходство между этой парой кластеров, нормализованное с учетом их внутреннего сходства<ref>http://studopedia.ru/7_41934_algoritm-dinamicheskoy-ierarhicheskoy-klasterizatsii-CHAMELEON.html</ref>.

'''Первый этап'''

На первом этапе, согласно графо-ориентированному подходу, происходит построение графа <math>G = (V, E)</math> на матрице сходства объектов по принципу k ближайших соседей. Две вершины такого графа соединяет ребро, если объект, соответствующий любой из этих вершин попадает в число k наиболее близких объектов для объекта, соответствующего другой вершине из данной пары.
[[Файл:Снимок chameleon 2.png|2000px|thumb|Рисунок 2. Объекты в пространстве - слева, граф по принципу 1-го ближайшего соседа - по центру, граф по принципу 3-х ближайших соседей - справа ]]

'''Второй этап'''

Алгоритм разделяет полученный граф на множество сравнительно малых подграфов <math>K= \{K_{i}\}</math>. Разделение происходит последовательно. На каждом шаге выбирается подграф, содержащий наибольшее число вершин. Этот граф разделяется на два подграфа так, что разделитель ребер графа минимален и каждый из получаемых подграфов содержит не менее 25 % вершин исходного графа. Процесс разделения останавливается, когда наибольший подграф содержит меньше некоторого заданного числа вершин. Обычно величина этого параметра задается равной значению от 1 до 5 % от числа объектов. Полученное множество связных графов считается множеством начальных кластеров, на котором требуется провести последовательное иерархическое объединение.

'''Третий этап'''

Третий этап заключается в итеративном преобразовании множества подграфов <math>K= \{K_{i}\}</math> в множество кластеров <math>C = \{C_{i}\}</math>. Алгоритм осуществляет агломеративную иерархическую кластеризацию на основании показателей <math>EC_{(C_{i},C_{j})}</math>, <math>S_{EC_{(C_{i},C_{j})}}</math>, <math>RI_{(C_{i},C_{j})} </math>, <math> RC_{(C_{i},C_{j})}</math>. Существует две стратегии анализа показателей сходства. Первая подразумевает наличие некоторых пороговых значений <math>T_{RI}</math> и <math>T_{RC}</math>. В соответствии с этой стратегией, алгоритм для каждого кластера <math>C_{i}</math> проверяет, отвечают ли смежные (наиболее близкие) ему кластеры условиям:

*<math>RI_{(C_{i},C_{j})} \geqslant T_{RI}</math>

*<math>RC_{(C_{i},C_{j})} \geqslant T_{RC}</math>

Если более одного смежного кластера отвечает этим условиям, то алгоритм выбирает для объединения наиболее связный кластер (граф), то есть такой кластер <math>C_{j}</math>, с которым у кластера <math>C_{i}</math> получается наибольшая абсолютная взаимная связность. По завершению прохода по всем кластерам, созданные таким образом пары объединяются. Параметры <math>T_{RI}</math> и <math>T_{RC}</math> могут использоваться для изменения характеристик получаемых кластеров.

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

<math>RI_{(C_{i},C_{j})}*RC_{(C_{i},C_{j})}^\alpha</math>,

где <math>\alpha</math> выбирается пользователем. Если <math>\alpha > 1 </math>, то алгоритм придает большее значение относительному взаимному сходству, а если <math>\alpha < 1 </math>, то большее значение имеет относительная взаимная связность.

''Вычисляемые данные'':

<math>U = (u_1, u_2, ..., u_n)</math> - n-мерный вектор, где <math>u_i \in N_{[C]}</math> - порядковый номер кластера, к которому принадлежит вершина i исходного множества V.

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

Алгоритм имеет три вычислительных ядра, по одному на каждый этап.

На первом этапе вычислительным ядром является процесс нахождения <math>k</math> ближайших соседей для каждой вершины, который заключается в анализе матрицы расстояний.

На втором этапе вычислительным ядром является процесс поиска подходящего разбиения очередного подграфа на два графа с минимизацией разделителя ребер графа.

На третьем этапе вычислительным ядром является расчет величин <math>EC_{(C_{i},C_{j})}</math>, <math>S_{EC_{(C_{i},C_{j})}}</math>, <math>RI_{(C_{i},C_{j})} </math>, <math> RC_{(C_{i},C_{j})}</math> для каждой пары смежных кластеров.

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

Как уже рассказывалось ранее, алгоритм включает в себя три основных этапа, каждый из которых, по сути, является отдельным алгоритмом. Этапы выполняются последовательно относительно друг друга.

Макрооперация на первом этапе - процедура нахождения <math>k</math> ближайших соседей, на втором - процедура разбиения наибольшего подграфа на два графа, на третьем - процедура вычисления показателей сходства, на основе которых принимается решение о слиянии подграфов в кластер.

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

'''Первый этап'''
<source lang="cpp">
int n; //количество вершин
int k; //количество соседей
int A[n][n] //матрица расстояний
int D[k] //массив вершин-соседей
int E[n][n] //матрица ребер графа <math>G_{2} = (K, E_{2})</math>
for i=1 to n-1 do
{
for j=i+1 to n do
{
//заполняем массив вершин-соседей вставляя новые вершины, если они ближе, чем самая далекая из массива.
}
for j=0 to k do
{
//для каждой вершины соседа заполняем соответствующую ячейку из матрицы E[n][n] единицей
}

}
</source>

'''Второй этап'''

1. Все связные подграфы в отсортированном порядке помещаются в список;
2. Берем наибольший элемент списка, вычисляем количество его вершин. Если число вершин > l, то идем в пункт 3. Иначе в пункт 5;
3. Разбиваем подграф на два подграфа таким образом, чтобы разделитель ребер графа был минимален и каждый из получаемых подграфов содержал не менее 25 % вершин исходного графа;
4. Добавляем полученные элементы в список подграфов таким образом, чтобы список оставался отсортированным. Идем в пункт 2;
5. Нашли искомое множество подграфов math>K = \{K_{i}\}</math>;
6. Создаем и заполняем матрицу матрицу расстояний для графа <math>G_{2} = (K, E_{2})</math>. Получаем искомый набор рёбер <math>E_{2}</math>.

'''Третий этап'''

1. Заводим два массива: а) массив кластеров C, полученных на предыдущем этапе, б) массив объединений кластеров F, которые мы будем получать на этом этапе;
2. Берем следующий кластер <math>C_{i}</math> (на первом шаге - первый). Если все кластеры просмотрены, идем в пункт 6;
3. Берем следующий кластер <math>C_{j}, i<>j</math>. Если все кластеры просмотрены, то идем в пункт 2;
4. Проверяем смежность <math>C_{i}</math> и <math>C_{j}</math>. Если не смежны, то возвращаемся в пункт 3. Если смежны, идем в пункт 5;
5. Рассчитываем показатели <math>RI_{(C_{i},C_{j})}</math> и <math> RC_{(C_{i},C_{j})}</math>. Проверяем, удовлетворяют ли найденные значения условиям:
*<math>RI_{(C_{i},C_{j})} \geqslant T_{RI}</math>
*<math>RC_{(C_{i},C_{j})} \geqslant T_{RC}</math>
Если нет, то идем в пункт 3. Иначе если смежность пары кластеров выше, чем у предыдущих найденных, то <math>F_{i}=j</math>. Идем в пункт 3;
6. Если в списке F есть хотя бы одна пара кластеров для слияния, то выполняем слияние, обновляем массив кластеров и массив объединений кластеров. Идем в пункт 2.

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

1) Для построения графа на основе метода k ближайших соседей для n вершин требуется <math>O(n log(n))</math> операций <ref>J.H. Friedman, J.L. Bentley, and R.A. Finkel. An algorithm for ﬁnding best matches in logarithmic expected time. ACM Transactions on Mathematical Software, 3:209–226, 1977.</ref>; для наборов данных большой размерности эта величина составляет <math>O(n^2)</math> операций <ref>S. Berchtold, C. Bohm, D. Keim, and H.-P. Kriegel. Cost model for nearest neighbor search in high dimensional data space. In Proc. of Symposium on Principles of Database Systems, Tucson, Arizona, 1997.</ref>;

2) Для выделения множества сравнительно малых связных подграфов требуется <math>nm</math> операций, где <math>m</math> - количество подграфов, полученных на втором этапе алгоритма;

3) Формирование набора кластеров, на основе множества подграфов, полученных на предыдущем этапе, требует <math>m^2log(m)</math> операций.

Итого, для n вершин получаем последовательную сложность <math>O(n log(n)+nm+m^2log(m))</math>.

== Информационный граф ==
[[File:СК.png]]

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

Первый этап работы алгоритма можно распределить между <math>n</math> процессами. На вход каждому процессу подается своя вершина, далее происходит процедура поиска <math>k</math> ближайших соседей. Параллельная сложность составляет <math>O(n)</math>.

Второй и третий этапы можно распараллелить частично.

Второй этап распараллеливается путем подачи на вход свободному процессу очередного подграфа для разделения. Число итераций оценивается в <math>O(n log(n))</math>.

Третий этап делится на расчет показателей схожести и соединение подграфов в кластеры. Процесс расчета показателей можно распараллелить, подавая каждому процессу на вход пару подграфов. Сложность этого процесса оценивается как <math>m log(m)</math>. Соединение подграфов в кластеры выполняется последовательно, сложность процесса составляет <math>m^2 log(m)</math>

Таким образом получаем общую параллельную сложность алгоритма: <math>O(n+ n log(n) + m^2 log (m) + m log(m))</math>

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

1. Симметрическая матрица <math>A</math> расстояний между элементами данных размера <math>n\times n</math> с нулями на главной диагонали (<math>a_{ii}= 0, i = 1, \ldots, N</math>).

2. <math>k</math> - количество ближайших соседей для вершин (рекомендуемое значение <math>k</math> от 5 до 20 в зависимости от количества анализируемых объектов).

3. <math>l</math> - наименьшее число вершин, которое может содержать наибольший подкластер на 2-м этапе . Величина этого параметра варьируется от 1 до 5 % от общего числа объектов.

'''Объём входных данных'''

<math>\frac{n (n - 1)}{2}</math> (в силу симметричности и нулевой главной диагонали достаточно хранить только над/поддиагональные элементы).

'''Выходные данные'''

Вектор из <math>n</math> чисел <math>u_{1}, u_{2}, \ldots, u_{N}</math>, где <math>u_{i}</math> - целое число, соответствующее кластеру <math>i</math>-го объекта.

'''Объём выходных данных'''

<math>n</math>

== Свойства алгоритма ==
Соотношение последовательной и параллельной сложности на первом этапе является ''линейным'' для больших наборов данных и логарифмическим для n вершин. На втором этапе сложно оценить это соотношение - оно сильно зависит от параметров <math>k</math> и <math>l</math>. На третьем этапе соотношение равно <math>O(1)</math>;

Оценка ''вычислительной мощности'' выглядит следующим образом:

<math>O(1)</math> для 1-го этапа;

<math>O(\frac{nm}{n^2+m^2})</math> для 2-го этапа;

<math>O(\frac{m^2log(m)}{m^2+n})</math> для 3-го этапа;

Алгоритм является ''недетерминированным''. Хотя 1-й этап детерминирован, на 2-ом этапе могут быть найдены различные разбиения на подграфы, что повлияет и на итоговый результат работы алгоритма.

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

Масштабируемость исследовалась на основе работы, презентующей пробную версию параллельной реализации алгоритма для различного числа потоков.
График показывает, что эффективность и скорость работы алгоритма растут с увеличением объема входных данных. Однако, в упомянутой выше работе отмечается, что эффективность алгоритма падает с ростом количества потоков.

[[File:Масштабирование.png|700px|center]]

== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Последовательная реализация алгоритма доступна по ссылке <ref>http://read.pudn.com/downloads36/sourcecode/math/115779/chameleon/chameleon.c__.htm</ref>.

CHAMELEON можно реализовать с использованием графовых библиотек METIS <ref>http://glaros.dtc.umn.edu/gkhome/metis/metis/overview
</ref>, hMETIS <ref>http://glaros.dtc.umn.edu/gkhome/metis/hmetis/overview</ref> и RANN <ref>https://cran.r-project.org/web/packages/RANN/index.html</ref>.

Существует исследование, связанное с реализацией CHAMELEON посредством технологии OpenMP, с которым можно ознакомиться здесь <ref>http://research.ijcaonline.org/volume79/number8/pxc3891600.pdf</ref>.

Параллельных реализаций алгоритма CHAMELEON не найдено.

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

Участник:ЕкатеринаКозырева/Алгоритм динамической иерархической кластеризации CHAMELEON

2016-11-20T13:53:42Z

ЕкатеринаКозырева: /* Масштабируемость алгоритма и его реализации */

{{algorithm
| name = Алгоритм динамической иерархической кластеризации CHAMELEON
| serial_complexity = <math>O(nm + n log n + m^2 log m)</math>
| input_data = <math>\frac{n (n - 1)}{2}</math>
| output_data = <math>n</math>
| pf_height = <math>O(n+ n log(n) + m^2 log (m) + m log(m))</math>
| pf_width = <math>O(n)</math>
}}

Автор описания [[Участник:ЕкатеринаКозырева|Е.А.Козырева]]
= Свойства и структура алгоритмов =

== Общее описание алгоритма ==
Алгоритм CHAMELEON был предложен в 1999 году тремя учеными из университета Миннесоты – George Karypis, Eui-Hong (Sam) Han и Vipin Kumar<ref>George Karypis, Eui-Hong (Sam) Han и Vipin Kumar, «Chameleon: Hierarchical Clustering Using Dynamic Modeling», 1999.</ref>.

Предназначен для решения задач кластеризации. Кластеризация (или кластерный анализ) — это задача разбиения множества объектов на группы, называемые кластерами. Внутри каждой группы должны оказаться «похожие» объекты, а объекты разных группы должны быть как можно более отличны.

CHAMELEON - это агломеративный иерархический алгоритм кластеризации, ключевой особенностью которого является то, что он учитывает и взаимную связность, и сходство при определении наиболее похожей пары подкластеров, основываясь на динамической модели. Это означает, что в процессе кластеризации два кластера объединяются, только если их относительная взаимная связность и относительное взаимное сходство являются высокими по отношению к внутренней взаимосвязанности кластеров и близости элементов внутри кластеров. Кроме того, CHAMELEON использует подход для моделирования степени взаимосвязанности и близости между каждой парой кластеров, который учитывает внутренние характеристики самих кластеров. Таким образом, он может автоматически адаптироваться к внутренним характеристикам объединяемых кластеров.

CHAMELEON находит кластеры в наборе данных с помощью трехфазного алгоритма. На первой фазе происходит построение графа, путём добавления рёбер по принципу k ближайших соседей. На второй фазе CHAMELEON группирует полученные элементы в множество относительно небольших подграфов. Во время третьей фазы применяется агломеративный иерархический алгоритм кластеризации, с помощью которого находятся естесственные кластеры путем многократного объединения подграфов, полученных на прошлом этапе.

[[File:Chameleon.png|1000px|thumb|center|Рисунок 1. Общая структура алгоритма CHAMELEON]]

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

''Исходные данные'':

* Множество из n точек <math>V= {v_{ij}}</math> в метрическом пространстве, которое задано симметрической матрицей расстояний <math>A</math> размера <math>n\times n</math>.
* <math>k</math> - количество ближайших соседей для вершин, <math>k \in N, k \leq n</math>.
* <math>l</math> - наименьшее число вершин, которое может содержать наибольший подграф на 2-м этапе, <math>l \in N, l \leq n</math>.

''Обозначения'':

* <math>G = (V, E)</math> - граф, полученный путём соединения каждой точки с её <math>k</math> ближайшими соседями.

* <math>K= \{K_{i}\}</math> - разбиение множества <math>V</math> на набор попарно непересекающихся связных подмножеств, полученное в результате выполнения второй фазы алгоритма.

* <math>G_{2} = (K, E_{2})</math> - взвешенный граф, вершинами которого являются получившиеся подграфы, а ребрами - количество ребер исходного графа, соединяющих соответствующие подграфы.

* <math>C = \{C_{i}\}</math> - итоговое разбиение множества вершин графа <math>G_{2}</math> на набор кластеров.

''Вспомогательные понятия''

*<math>EC_{(C_{i},C_{j})}</math> - абсолютная взаимная связность пары кластеров <math>C_{i}, C{j}</math>. Определяется как сумма весов ребер, соединяющих вершины, принадлежащие <math>C{i}</math> c вершинами из <math>C{j}</math>. Внутренняя связность <math>EC_{(C_{i},C_{i})}</math> вычисляется как сумма ребер, входящих в разделитель, разбивающий <math>C{i}</math> на два равных подграфа.

*<math>RI_{(C_{i},C_{j})} = \frac{|EC_{(C_{i},C_{j})}|}{(|EC_{C_{i}}|+|EC_{C_{j}}|)/2}</math> - относительная взаимная связность пары кластеров <math>C_{i}, C{j}</math>

*<math>S_{EC_{(C_{i},C_{j})}}</math> - абсолютное взаимное сходство пары кластеров <math>C_{i}, C{j}</math>. Подсчитывается как среднее сходство между соединенными вершинами, принадлежащими <math>C{i}</math> и <math>C{j}</math> соответственно. Соединения обусловлены разбиением общего графа, полученного на первом этапе алгоритма.

*<math> RC_{(C_{i},C_{j})}= \frac{S_{EC_{(C_{i},C_{j})}}}{\frac{|C_{i}|}{|C_{i}+C_{j}|}*S_{EC_{(C_{i})}}+\frac{|C_{i}|}{|C_{i}+C_{j}|}*S_{EC_{(C_{j})}}}</math> - относительное взаимное сходство пары кластеров <math>C_{i}, C{j}</math>. Определяется как абсолютное сходство между этой парой кластеров, нормализованное с учетом их внутреннего сходства<ref>http://studopedia.ru/7_41934_algoritm-dinamicheskoy-ierarhicheskoy-klasterizatsii-CHAMELEON.html</ref>.

'''Первый этап'''

На первом этапе, согласно графо-ориентированному подходу, происходит построение графа <math>G = (V, E)</math> на матрице сходства объектов по принципу k ближайших соседей. Две вершины такого графа соединяет ребро, если объект, соответствующий любой из этих вершин попадает в число k наиболее близких объектов для объекта, соответствующего другой вершине из данной пары.
[[Файл:Снимок chameleon 2.png|2000px|thumb|Рисунок 2. Объекты в пространстве - слева, граф по принципу 1-го ближайшего соседа - по центру, граф по принципу 3-х ближайших соседей - справа ]]

'''Второй этап'''

Алгоритм разделяет полученный граф на множество сравнительно малых подграфов <math>K= \{K_{i}\}</math>. Разделение происходит последовательно. На каждом шаге выбирается подграф, содержащий наибольшее число вершин. Этот граф разделяется на два подграфа так, что разделитель ребер графа минимален и каждый из получаемых подграфов содержит не менее 25 % вершин исходного графа. Процесс разделения останавливается, когда наибольший подграф содержит меньше некоторого заданного числа вершин. Обычно величина этого параметра задается равной значению от 1 до 5 % от числа объектов. Полученное множество связных графов считается множеством начальных кластеров, на котором требуется провести последовательное иерархическое объединение.

'''Третий этап'''

Третий этап заключается в итеративном преобразовании множества подграфов <math>K= \{K_{i}\}</math> в множество кластеров <math>C = \{C_{i}\}</math>. Алгоритм осуществляет агломеративную иерархическую кластеризацию на основании показателей <math>EC_{(C_{i},C_{j})}</math>, <math>S_{EC_{(C_{i},C_{j})}}</math>, <math>RI_{(C_{i},C_{j})} </math>, <math> RC_{(C_{i},C_{j})}</math>. Существует две стратегии анализа показателей сходства. Первая подразумевает наличие некоторых пороговых значений <math>T_{RI}</math> и <math>T_{RC}</math>. В соответствии с этой стратегией, алгоритм для каждого кластера <math>C_{i}</math> проверяет, отвечают ли смежные (наиболее близкие) ему кластеры условиям:

*<math>RI_{(C_{i},C_{j})} \geqslant T_{RI}</math>

*<math>RC_{(C_{i},C_{j})} \geqslant T_{RC}</math>

Если более одного смежного кластера отвечает этим условиям, то алгоритм выбирает для объединения наиболее связный кластер (граф), то есть такой кластер <math>C_{j}</math>, с которым у кластера <math>C_{i}</math> получается наибольшая абсолютная взаимная связность. По завершению прохода по всем кластерам, созданные таким образом пары объединяются. Параметры <math>T_{RI}</math> и <math>T_{RC}</math> могут использоваться для изменения характеристик получаемых кластеров.

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

<math>RI_{(C_{i},C_{j})}*RC_{(C_{i},C_{j})}^\alpha</math>,

где <math>\alpha</math> выбирается пользователем. Если <math>\alpha > 1 </math>, то алгоритм придает большее значение относительному взаимному сходству, а если <math>\alpha < 1 </math>, то большее значение имеет относительная взаимная связность.

''Вычисляемые данные'':

<math>U = (u_1, u_2, ..., u_n)</math> - n-мерный вектор, где <math>u_i \in N_{[C]}</math> - порядковый номер кластера, к которому принадлежит вершина i исходного множества V.

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

Алгоритм имеет три вычислительных ядра, по одному на каждый этап.

На первом этапе вычислительным ядром является процесс нахождения <math>k</math> ближайших соседей для каждой вершины, который заключается в анализе матрицы расстояний.

На втором этапе вычислительным ядром является процесс поиска подходящего разбиения очередного подграфа на два графа с минимизацией разделителя ребер графа.

На третьем этапе вычислительным ядром является расчет величин <math>EC_{(C_{i},C_{j})}</math>, <math>S_{EC_{(C_{i},C_{j})}}</math>, <math>RI_{(C_{i},C_{j})} </math>, <math> RC_{(C_{i},C_{j})}</math> для каждой пары смежных кластеров.

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

Как уже рассказывалось ранее, алгоритм включает в себя три основных этапа, каждый из которых, по сути, является отдельным алгоритмом. Этапы выполняются последовательно относительно друг друга.

Макрооперация на первом этапе - процедура нахождения <math>k</math> ближайших соседей, на втором - процедура разбиения наибольшего подграфа на два графа, на третьем - процедура вычисления показателей сходства, на основе которых принимается решение о слиянии подграфов в кластер.

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

'''Первый этап'''
<source lang="cpp">
int n; //количество вершин
int k; //количество соседей
int A[n][n] //матрица расстояний
int D[k] //массив вершин-соседей
int E[n][n] //матрица ребер графа <math>G_{2} = (K, E_{2})</math>
for i=1 to n-1 do
{
for j=i+1 to n do
{
//заполняем массив вершин-соседей вставляя новые вершины, если они ближе, чем самая далекая из массива.
}
for j=0 to k do
{
//для каждой вершины соседа заполняем соответствующую ячейку из матрицы E[n][n] единицей
}

}
</source>

'''Второй этап'''

1. Все связные подграфы в отсортированном порядке помещаются в список;
2. Берем наибольший элемент списка, вычисляем количество его вершин. Если число вершин > l, то идем в пункт 3. Иначе в пункт 5;
3. Разбиваем подграф на два подграфа таким образом, чтобы разделитель ребер графа был минимален и каждый из получаемых подграфов содержал не менее 25 % вершин исходного графа;
4. Добавляем полученные элементы в список подграфов таким образом, чтобы список оставался отсортированным. Идем в пункт 2;
5. Нашли искомое множество подграфов math>K = \{K_{i}\}</math>;
6. Создаем и заполняем матрицу матрицу расстояний для графа <math>G_{2} = (K, E_{2})</math>. Получаем искомый набор рёбер <math>E_{2}</math>.

'''Третий этап'''

1. Заводим два массива: а) массив кластеров C, полученных на предыдущем этапе, б) массив объединений кластеров F, которые мы будем получать на этом этапе;
2. Берем следующий кластер <math>C_{i}</math> (на первом шаге - первый). Если все кластеры просмотрены, идем в пункт 6;
3. Берем следующий кластер <math>C_{j}, i<>j</math>. Если все кластеры просмотрены, то идем в пункт 2;
4. Проверяем смежность <math>C_{i}</math> и <math>C_{j}</math>. Если не смежны, то возвращаемся в пункт 3. Если смежны, идем в пункт 5;
5. Рассчитываем показатели <math>RI_{(C_{i},C_{j})}</math> и <math> RC_{(C_{i},C_{j})}</math>. Проверяем, удовлетворяют ли найденные значения условиям:
*<math>RI_{(C_{i},C_{j})} \geqslant T_{RI}</math>
*<math>RC_{(C_{i},C_{j})} \geqslant T_{RC}</math>
Если нет, то идем в пункт 3. Иначе если смежность пары кластеров выше, чем у предыдущих найденных, то <math>F_{i}=j</math>. Идем в пункт 3;
6. Если в списке F есть хотя бы одна пара кластеров для слияния, то выполняем слияние, обновляем массив кластеров и массив объединений кластеров. Идем в пункт 2.

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

1) Для построения графа на основе метода k ближайших соседей для n вершин требуется <math>O(n log(n))</math> операций <ref>J.H. Friedman, J.L. Bentley, and R.A. Finkel. An algorithm for ﬁnding best matches in logarithmic expected time. ACM Transactions on Mathematical Software, 3:209–226, 1977.</ref>; для наборов данных большой размерности эта величина составляет <math>O(n^2)</math> операций <ref>S. Berchtold, C. Bohm, D. Keim, and H.-P. Kriegel. Cost model for nearest neighbor search in high dimensional data space. In Proc. of Symposium on Principles of Database Systems, Tucson, Arizona, 1997.</ref>;

2) Для выделения множества сравнительно малых связных подграфов требуется <math>nm</math> операций, где <math>m</math> - количество подграфов, полученных на втором этапе алгоритма;

3) Формирование набора кластеров, на основе множества подграфов, полученных на предыдущем этапе, требует <math>m^2log(m)</math> операций.

Итого, для n вершин получаем последовательную сложность <math>O(n log(n)+nm+m^2log(m))</math>.

== Информационный граф ==
[[File:СК.png]]

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

Первый этап работы алгоритма можно распределить между <math>n</math> процессами. На вход каждому процессу подается своя вершина, далее происходит процедура поиска <math>k</math> ближайших соседей. Параллельная сложность составляет <math>O(n)</math>.

Второй и третий этапы можно распараллелить частично.

Второй этап распараллеливается путем подачи на вход свободному процессу очередного подграфа для разделения. Число итераций оценивается в <math>O(n log(n))</math>.

Третий этап делится на расчет показателей схожести и соединение подграфов в кластеры. Процесс расчета показателей можно распараллелить, подавая каждому процессу на вход пару подграфов. Сложность этого процесса оценивается как <math>m log(m)</math>. Соединение подграфов в кластеры выполняется последовательно, сложность процесса составляет <math>m^2 log(m)</math>

Таким образом получаем общую параллельную сложность алгоритма: <math>O(n+ n log(n) + m^2 log (m) + m log(m))</math>

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

1. Симметрическая матрица <math>A</math> расстояний между элементами данных размера <math>n\times n</math> с нулями на главной диагонали (<math>a_{ii}= 0, i = 1, \ldots, N</math>).

2. <math>k</math> - количество ближайших соседей для вершин (рекомендуемое значение <math>k</math> от 5 до 20 в зависимости от количества анализируемых объектов).

3. <math>l</math> - наименьшее число вершин, которое может содержать наибольший подкластер на 2-м этапе . Величина этого параметра варьируется от 1 до 5 % от общего числа объектов.

'''Объём входных данных'''

<math>\frac{n (n - 1)}{2}</math> (в силу симметричности и нулевой главной диагонали достаточно хранить только над/поддиагональные элементы).

'''Выходные данные'''

Вектор из <math>n</math> чисел <math>u_{1}, u_{2}, \ldots, u_{N}</math>, где <math>u_{i}</math> - целое число, соответствующее кластеру <math>i</math>-го объекта.

'''Объём выходных данных'''

<math>n</math>

== Свойства алгоритма ==
Соотношение последовательной и параллельной сложности на первом этапе является ''линейным'' для больших наборов данных и логарифмическим для n вершин. На втором этапе сложно оценить это соотношение - оно сильно зависит от параметров <math>k</math> и <math>l</math>. На третьем этапе соотношение равно <math>O(1)</math>;

Оценка ''вычислительной мощности'' выглядит следующим образом:

<math>O(1)</math> для 1-го этапа;

<math>O(\frac{nm}{n^2+m^2})</math> для 2-го этапа;

<math>O(\frac{m^2log(m)}{m^2+n})</math> для 3-го этапа;

Алгоритм является ''недетерминированным''. Хотя 1-й этап детерминирован, на 2-ом этапе могут быть найдены различные разбиения на подграфы, что повлияет и на итоговый результат работы алгоритма.

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

[[File:Масштабирование.png|700px|center]]

== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Последовательная реализация алгоритма доступна по ссылке <ref>http://read.pudn.com/downloads36/sourcecode/math/115779/chameleon/chameleon.c__.htm</ref>.

CHAMELEON можно реализовать с использованием графовых библиотек METIS <ref>http://glaros.dtc.umn.edu/gkhome/metis/metis/overview
</ref>, hMETIS <ref>http://glaros.dtc.umn.edu/gkhome/metis/hmetis/overview</ref> и RANN <ref>https://cran.r-project.org/web/packages/RANN/index.html</ref>.

Существует исследование, связанное с реализацией CHAMELEON посредством технологии OpenMP, с которым можно ознакомиться здесь <ref>http://research.ijcaonline.org/volume79/number8/pxc3891600.pdf</ref>.

Параллельных реализаций алгоритма CHAMELEON не найдено.

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

Участник:ЕкатеринаКозырева/Алгоритм динамической иерархической кластеризации CHAMELEON

2016-11-20T13:52:45Z

ЕкатеринаКозырева: /* Масштабируемость алгоритма и его реализации */

{{algorithm
| name = Алгоритм динамической иерархической кластеризации CHAMELEON
| serial_complexity = <math>O(nm + n log n + m^2 log m)</math>
| input_data = <math>\frac{n (n - 1)}{2}</math>
| output_data = <math>n</math>
| pf_height = <math>O(n+ n log(n) + m^2 log (m) + m log(m))</math>
| pf_width = <math>O(n)</math>
}}

Автор описания [[Участник:ЕкатеринаКозырева|Е.А.Козырева]]
= Свойства и структура алгоритмов =

== Общее описание алгоритма ==
Алгоритм CHAMELEON был предложен в 1999 году тремя учеными из университета Миннесоты – George Karypis, Eui-Hong (Sam) Han и Vipin Kumar<ref>George Karypis, Eui-Hong (Sam) Han и Vipin Kumar, «Chameleon: Hierarchical Clustering Using Dynamic Modeling», 1999.</ref>.

Предназначен для решения задач кластеризации. Кластеризация (или кластерный анализ) — это задача разбиения множества объектов на группы, называемые кластерами. Внутри каждой группы должны оказаться «похожие» объекты, а объекты разных группы должны быть как можно более отличны.

CHAMELEON - это агломеративный иерархический алгоритм кластеризации, ключевой особенностью которого является то, что он учитывает и взаимную связность, и сходство при определении наиболее похожей пары подкластеров, основываясь на динамической модели. Это означает, что в процессе кластеризации два кластера объединяются, только если их относительная взаимная связность и относительное взаимное сходство являются высокими по отношению к внутренней взаимосвязанности кластеров и близости элементов внутри кластеров. Кроме того, CHAMELEON использует подход для моделирования степени взаимосвязанности и близости между каждой парой кластеров, который учитывает внутренние характеристики самих кластеров. Таким образом, он может автоматически адаптироваться к внутренним характеристикам объединяемых кластеров.

CHAMELEON находит кластеры в наборе данных с помощью трехфазного алгоритма. На первой фазе происходит построение графа, путём добавления рёбер по принципу k ближайших соседей. На второй фазе CHAMELEON группирует полученные элементы в множество относительно небольших подграфов. Во время третьей фазы применяется агломеративный иерархический алгоритм кластеризации, с помощью которого находятся естесственные кластеры путем многократного объединения подграфов, полученных на прошлом этапе.

[[File:Chameleon.png|1000px|thumb|center|Рисунок 1. Общая структура алгоритма CHAMELEON]]

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

''Исходные данные'':

* Множество из n точек <math>V= {v_{ij}}</math> в метрическом пространстве, которое задано симметрической матрицей расстояний <math>A</math> размера <math>n\times n</math>.
* <math>k</math> - количество ближайших соседей для вершин, <math>k \in N, k \leq n</math>.
* <math>l</math> - наименьшее число вершин, которое может содержать наибольший подграф на 2-м этапе, <math>l \in N, l \leq n</math>.

''Обозначения'':

* <math>G = (V, E)</math> - граф, полученный путём соединения каждой точки с её <math>k</math> ближайшими соседями.

* <math>K= \{K_{i}\}</math> - разбиение множества <math>V</math> на набор попарно непересекающихся связных подмножеств, полученное в результате выполнения второй фазы алгоритма.

* <math>G_{2} = (K, E_{2})</math> - взвешенный граф, вершинами которого являются получившиеся подграфы, а ребрами - количество ребер исходного графа, соединяющих соответствующие подграфы.

* <math>C = \{C_{i}\}</math> - итоговое разбиение множества вершин графа <math>G_{2}</math> на набор кластеров.

''Вспомогательные понятия''

*<math>EC_{(C_{i},C_{j})}</math> - абсолютная взаимная связность пары кластеров <math>C_{i}, C{j}</math>. Определяется как сумма весов ребер, соединяющих вершины, принадлежащие <math>C{i}</math> c вершинами из <math>C{j}</math>. Внутренняя связность <math>EC_{(C_{i},C_{i})}</math> вычисляется как сумма ребер, входящих в разделитель, разбивающий <math>C{i}</math> на два равных подграфа.

*<math>RI_{(C_{i},C_{j})} = \frac{|EC_{(C_{i},C_{j})}|}{(|EC_{C_{i}}|+|EC_{C_{j}}|)/2}</math> - относительная взаимная связность пары кластеров <math>C_{i}, C{j}</math>

*<math>S_{EC_{(C_{i},C_{j})}}</math> - абсолютное взаимное сходство пары кластеров <math>C_{i}, C{j}</math>. Подсчитывается как среднее сходство между соединенными вершинами, принадлежащими <math>C{i}</math> и <math>C{j}</math> соответственно. Соединения обусловлены разбиением общего графа, полученного на первом этапе алгоритма.

*<math> RC_{(C_{i},C_{j})}= \frac{S_{EC_{(C_{i},C_{j})}}}{\frac{|C_{i}|}{|C_{i}+C_{j}|}*S_{EC_{(C_{i})}}+\frac{|C_{i}|}{|C_{i}+C_{j}|}*S_{EC_{(C_{j})}}}</math> - относительное взаимное сходство пары кластеров <math>C_{i}, C{j}</math>. Определяется как абсолютное сходство между этой парой кластеров, нормализованное с учетом их внутреннего сходства<ref>http://studopedia.ru/7_41934_algoritm-dinamicheskoy-ierarhicheskoy-klasterizatsii-CHAMELEON.html</ref>.

'''Первый этап'''

На первом этапе, согласно графо-ориентированному подходу, происходит построение графа <math>G = (V, E)</math> на матрице сходства объектов по принципу k ближайших соседей. Две вершины такого графа соединяет ребро, если объект, соответствующий любой из этих вершин попадает в число k наиболее близких объектов для объекта, соответствующего другой вершине из данной пары.
[[Файл:Снимок chameleon 2.png|2000px|thumb|Рисунок 2. Объекты в пространстве - слева, граф по принципу 1-го ближайшего соседа - по центру, граф по принципу 3-х ближайших соседей - справа ]]

'''Второй этап'''

Алгоритм разделяет полученный граф на множество сравнительно малых подграфов <math>K= \{K_{i}\}</math>. Разделение происходит последовательно. На каждом шаге выбирается подграф, содержащий наибольшее число вершин. Этот граф разделяется на два подграфа так, что разделитель ребер графа минимален и каждый из получаемых подграфов содержит не менее 25 % вершин исходного графа. Процесс разделения останавливается, когда наибольший подграф содержит меньше некоторого заданного числа вершин. Обычно величина этого параметра задается равной значению от 1 до 5 % от числа объектов. Полученное множество связных графов считается множеством начальных кластеров, на котором требуется провести последовательное иерархическое объединение.

'''Третий этап'''

Третий этап заключается в итеративном преобразовании множества подграфов <math>K= \{K_{i}\}</math> в множество кластеров <math>C = \{C_{i}\}</math>. Алгоритм осуществляет агломеративную иерархическую кластеризацию на основании показателей <math>EC_{(C_{i},C_{j})}</math>, <math>S_{EC_{(C_{i},C_{j})}}</math>, <math>RI_{(C_{i},C_{j})} </math>, <math> RC_{(C_{i},C_{j})}</math>. Существует две стратегии анализа показателей сходства. Первая подразумевает наличие некоторых пороговых значений <math>T_{RI}</math> и <math>T_{RC}</math>. В соответствии с этой стратегией, алгоритм для каждого кластера <math>C_{i}</math> проверяет, отвечают ли смежные (наиболее близкие) ему кластеры условиям:

*<math>RI_{(C_{i},C_{j})} \geqslant T_{RI}</math>

*<math>RC_{(C_{i},C_{j})} \geqslant T_{RC}</math>

Если более одного смежного кластера отвечает этим условиям, то алгоритм выбирает для объединения наиболее связный кластер (граф), то есть такой кластер <math>C_{j}</math>, с которым у кластера <math>C_{i}</math> получается наибольшая абсолютная взаимная связность. По завершению прохода по всем кластерам, созданные таким образом пары объединяются. Параметры <math>T_{RI}</math> и <math>T_{RC}</math> могут использоваться для изменения характеристик получаемых кластеров.

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

<math>RI_{(C_{i},C_{j})}*RC_{(C_{i},C_{j})}^\alpha</math>,

где <math>\alpha</math> выбирается пользователем. Если <math>\alpha > 1 </math>, то алгоритм придает большее значение относительному взаимному сходству, а если <math>\alpha < 1 </math>, то большее значение имеет относительная взаимная связность.

''Вычисляемые данные'':

<math>U = (u_1, u_2, ..., u_n)</math> - n-мерный вектор, где <math>u_i \in N_{[C]}</math> - порядковый номер кластера, к которому принадлежит вершина i исходного множества V.

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

Алгоритм имеет три вычислительных ядра, по одному на каждый этап.

На первом этапе вычислительным ядром является процесс нахождения <math>k</math> ближайших соседей для каждой вершины, который заключается в анализе матрицы расстояний.

На втором этапе вычислительным ядром является процесс поиска подходящего разбиения очередного подграфа на два графа с минимизацией разделителя ребер графа.

На третьем этапе вычислительным ядром является расчет величин <math>EC_{(C_{i},C_{j})}</math>, <math>S_{EC_{(C_{i},C_{j})}}</math>, <math>RI_{(C_{i},C_{j})} </math>, <math> RC_{(C_{i},C_{j})}</math> для каждой пары смежных кластеров.

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

Как уже рассказывалось ранее, алгоритм включает в себя три основных этапа, каждый из которых, по сути, является отдельным алгоритмом. Этапы выполняются последовательно относительно друг друга.

Макрооперация на первом этапе - процедура нахождения <math>k</math> ближайших соседей, на втором - процедура разбиения наибольшего подграфа на два графа, на третьем - процедура вычисления показателей сходства, на основе которых принимается решение о слиянии подграфов в кластер.

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

'''Первый этап'''
<source lang="cpp">
int n; //количество вершин
int k; //количество соседей
int A[n][n] //матрица расстояний
int D[k] //массив вершин-соседей
int E[n][n] //матрица ребер графа <math>G_{2} = (K, E_{2})</math>
for i=1 to n-1 do
{
for j=i+1 to n do
{
//заполняем массив вершин-соседей вставляя новые вершины, если они ближе, чем самая далекая из массива.
}
for j=0 to k do
{
//для каждой вершины соседа заполняем соответствующую ячейку из матрицы E[n][n] единицей
}

}
</source>

'''Второй этап'''

1. Все связные подграфы в отсортированном порядке помещаются в список;
2. Берем наибольший элемент списка, вычисляем количество его вершин. Если число вершин > l, то идем в пункт 3. Иначе в пункт 5;
3. Разбиваем подграф на два подграфа таким образом, чтобы разделитель ребер графа был минимален и каждый из получаемых подграфов содержал не менее 25 % вершин исходного графа;
4. Добавляем полученные элементы в список подграфов таким образом, чтобы список оставался отсортированным. Идем в пункт 2;
5. Нашли искомое множество подграфов math>K = \{K_{i}\}</math>;
6. Создаем и заполняем матрицу матрицу расстояний для графа <math>G_{2} = (K, E_{2})</math>. Получаем искомый набор рёбер <math>E_{2}</math>.

'''Третий этап'''

1. Заводим два массива: а) массив кластеров C, полученных на предыдущем этапе, б) массив объединений кластеров F, которые мы будем получать на этом этапе;
2. Берем следующий кластер <math>C_{i}</math> (на первом шаге - первый). Если все кластеры просмотрены, идем в пункт 6;
3. Берем следующий кластер <math>C_{j}, i<>j</math>. Если все кластеры просмотрены, то идем в пункт 2;
4. Проверяем смежность <math>C_{i}</math> и <math>C_{j}</math>. Если не смежны, то возвращаемся в пункт 3. Если смежны, идем в пункт 5;
5. Рассчитываем показатели <math>RI_{(C_{i},C_{j})}</math> и <math> RC_{(C_{i},C_{j})}</math>. Проверяем, удовлетворяют ли найденные значения условиям:
*<math>RI_{(C_{i},C_{j})} \geqslant T_{RI}</math>
*<math>RC_{(C_{i},C_{j})} \geqslant T_{RC}</math>
Если нет, то идем в пункт 3. Иначе если смежность пары кластеров выше, чем у предыдущих найденных, то <math>F_{i}=j</math>. Идем в пункт 3;
6. Если в списке F есть хотя бы одна пара кластеров для слияния, то выполняем слияние, обновляем массив кластеров и массив объединений кластеров. Идем в пункт 2.

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

1) Для построения графа на основе метода k ближайших соседей для n вершин требуется <math>O(n log(n))</math> операций <ref>J.H. Friedman, J.L. Bentley, and R.A. Finkel. An algorithm for ﬁnding best matches in logarithmic expected time. ACM Transactions on Mathematical Software, 3:209–226, 1977.</ref>; для наборов данных большой размерности эта величина составляет <math>O(n^2)</math> операций <ref>S. Berchtold, C. Bohm, D. Keim, and H.-P. Kriegel. Cost model for nearest neighbor search in high dimensional data space. In Proc. of Symposium on Principles of Database Systems, Tucson, Arizona, 1997.</ref>;

2) Для выделения множества сравнительно малых связных подграфов требуется <math>nm</math> операций, где <math>m</math> - количество подграфов, полученных на втором этапе алгоритма;

3) Формирование набора кластеров, на основе множества подграфов, полученных на предыдущем этапе, требует <math>m^2log(m)</math> операций.

Итого, для n вершин получаем последовательную сложность <math>O(n log(n)+nm+m^2log(m))</math>.

== Информационный граф ==
[[File:СК.png]]

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

Первый этап работы алгоритма можно распределить между <math>n</math> процессами. На вход каждому процессу подается своя вершина, далее происходит процедура поиска <math>k</math> ближайших соседей. Параллельная сложность составляет <math>O(n)</math>.

Второй и третий этапы можно распараллелить частично.

Второй этап распараллеливается путем подачи на вход свободному процессу очередного подграфа для разделения. Число итераций оценивается в <math>O(n log(n))</math>.

Третий этап делится на расчет показателей схожести и соединение подграфов в кластеры. Процесс расчета показателей можно распараллелить, подавая каждому процессу на вход пару подграфов. Сложность этого процесса оценивается как <math>m log(m)</math>. Соединение подграфов в кластеры выполняется последовательно, сложность процесса составляет <math>m^2 log(m)</math>

Таким образом получаем общую параллельную сложность алгоритма: <math>O(n+ n log(n) + m^2 log (m) + m log(m))</math>

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

1. Симметрическая матрица <math>A</math> расстояний между элементами данных размера <math>n\times n</math> с нулями на главной диагонали (<math>a_{ii}= 0, i = 1, \ldots, N</math>).

2. <math>k</math> - количество ближайших соседей для вершин (рекомендуемое значение <math>k</math> от 5 до 20 в зависимости от количества анализируемых объектов).

3. <math>l</math> - наименьшее число вершин, которое может содержать наибольший подкластер на 2-м этапе . Величина этого параметра варьируется от 1 до 5 % от общего числа объектов.

'''Объём входных данных'''

<math>\frac{n (n - 1)}{2}</math> (в силу симметричности и нулевой главной диагонали достаточно хранить только над/поддиагональные элементы).

'''Выходные данные'''

Вектор из <math>n</math> чисел <math>u_{1}, u_{2}, \ldots, u_{N}</math>, где <math>u_{i}</math> - целое число, соответствующее кластеру <math>i</math>-го объекта.

'''Объём выходных данных'''

<math>n</math>

== Свойства алгоритма ==
Соотношение последовательной и параллельной сложности на первом этапе является ''линейным'' для больших наборов данных и логарифмическим для n вершин. На втором этапе сложно оценить это соотношение - оно сильно зависит от параметров <math>k</math> и <math>l</math>. На третьем этапе соотношение равно <math>O(1)</math>;

Оценка ''вычислительной мощности'' выглядит следующим образом:

<math>O(1)</math> для 1-го этапа;

<math>O(\frac{nm}{n^2+m^2})</math> для 2-го этапа;

<math>O(\frac{m^2log(m)}{m^2+n})</math> для 3-го этапа;

Алгоритм является ''недетерминированным''. Хотя 1-й этап детерминирован, на 2-ом этапе могут быть найдены различные разбиения на подграфы, что повлияет и на итоговый результат работы алгоритма.

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

[[File:Масштабирование.png|700px]]

== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Последовательная реализация алгоритма доступна по ссылке <ref>http://read.pudn.com/downloads36/sourcecode/math/115779/chameleon/chameleon.c__.htm</ref>.

CHAMELEON можно реализовать с использованием графовых библиотек METIS <ref>http://glaros.dtc.umn.edu/gkhome/metis/metis/overview
</ref>, hMETIS <ref>http://glaros.dtc.umn.edu/gkhome/metis/hmetis/overview</ref> и RANN <ref>https://cran.r-project.org/web/packages/RANN/index.html</ref>.

Существует исследование, связанное с реализацией CHAMELEON посредством технологии OpenMP, с которым можно ознакомиться здесь <ref>http://research.ijcaonline.org/volume79/number8/pxc3891600.pdf</ref>.

Параллельных реализаций алгоритма CHAMELEON не найдено.

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

Участник:ЕкатеринаКозырева/Алгоритм динамической иерархической кластеризации CHAMELEON

2016-11-20T13:52:24Z

ЕкатеринаКозырева: /* Масштабируемость алгоритма и его реализации */

{{algorithm
| name = Алгоритм динамической иерархической кластеризации CHAMELEON
| serial_complexity = <math>O(nm + n log n + m^2 log m)</math>
| input_data = <math>\frac{n (n - 1)}{2}</math>
| output_data = <math>n</math>
| pf_height = <math>O(n+ n log(n) + m^2 log (m) + m log(m))</math>
| pf_width = <math>O(n)</math>
}}

Автор описания [[Участник:ЕкатеринаКозырева|Е.А.Козырева]]
= Свойства и структура алгоритмов =

== Общее описание алгоритма ==
Алгоритм CHAMELEON был предложен в 1999 году тремя учеными из университета Миннесоты – George Karypis, Eui-Hong (Sam) Han и Vipin Kumar<ref>George Karypis, Eui-Hong (Sam) Han и Vipin Kumar, «Chameleon: Hierarchical Clustering Using Dynamic Modeling», 1999.</ref>.

Предназначен для решения задач кластеризации. Кластеризация (или кластерный анализ) — это задача разбиения множества объектов на группы, называемые кластерами. Внутри каждой группы должны оказаться «похожие» объекты, а объекты разных группы должны быть как можно более отличны.

CHAMELEON - это агломеративный иерархический алгоритм кластеризации, ключевой особенностью которого является то, что он учитывает и взаимную связность, и сходство при определении наиболее похожей пары подкластеров, основываясь на динамической модели. Это означает, что в процессе кластеризации два кластера объединяются, только если их относительная взаимная связность и относительное взаимное сходство являются высокими по отношению к внутренней взаимосвязанности кластеров и близости элементов внутри кластеров. Кроме того, CHAMELEON использует подход для моделирования степени взаимосвязанности и близости между каждой парой кластеров, который учитывает внутренние характеристики самих кластеров. Таким образом, он может автоматически адаптироваться к внутренним характеристикам объединяемых кластеров.

CHAMELEON находит кластеры в наборе данных с помощью трехфазного алгоритма. На первой фазе происходит построение графа, путём добавления рёбер по принципу k ближайших соседей. На второй фазе CHAMELEON группирует полученные элементы в множество относительно небольших подграфов. Во время третьей фазы применяется агломеративный иерархический алгоритм кластеризации, с помощью которого находятся естесственные кластеры путем многократного объединения подграфов, полученных на прошлом этапе.

[[File:Chameleon.png|1000px|thumb|center|Рисунок 1. Общая структура алгоритма CHAMELEON]]

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

''Исходные данные'':

* Множество из n точек <math>V= {v_{ij}}</math> в метрическом пространстве, которое задано симметрической матрицей расстояний <math>A</math> размера <math>n\times n</math>.
* <math>k</math> - количество ближайших соседей для вершин, <math>k \in N, k \leq n</math>.
* <math>l</math> - наименьшее число вершин, которое может содержать наибольший подграф на 2-м этапе, <math>l \in N, l \leq n</math>.

''Обозначения'':

* <math>G = (V, E)</math> - граф, полученный путём соединения каждой точки с её <math>k</math> ближайшими соседями.

* <math>K= \{K_{i}\}</math> - разбиение множества <math>V</math> на набор попарно непересекающихся связных подмножеств, полученное в результате выполнения второй фазы алгоритма.

* <math>G_{2} = (K, E_{2})</math> - взвешенный граф, вершинами которого являются получившиеся подграфы, а ребрами - количество ребер исходного графа, соединяющих соответствующие подграфы.

* <math>C = \{C_{i}\}</math> - итоговое разбиение множества вершин графа <math>G_{2}</math> на набор кластеров.

''Вспомогательные понятия''

*<math>EC_{(C_{i},C_{j})}</math> - абсолютная взаимная связность пары кластеров <math>C_{i}, C{j}</math>. Определяется как сумма весов ребер, соединяющих вершины, принадлежащие <math>C{i}</math> c вершинами из <math>C{j}</math>. Внутренняя связность <math>EC_{(C_{i},C_{i})}</math> вычисляется как сумма ребер, входящих в разделитель, разбивающий <math>C{i}</math> на два равных подграфа.

*<math>RI_{(C_{i},C_{j})} = \frac{|EC_{(C_{i},C_{j})}|}{(|EC_{C_{i}}|+|EC_{C_{j}}|)/2}</math> - относительная взаимная связность пары кластеров <math>C_{i}, C{j}</math>

*<math>S_{EC_{(C_{i},C_{j})}}</math> - абсолютное взаимное сходство пары кластеров <math>C_{i}, C{j}</math>. Подсчитывается как среднее сходство между соединенными вершинами, принадлежащими <math>C{i}</math> и <math>C{j}</math> соответственно. Соединения обусловлены разбиением общего графа, полученного на первом этапе алгоритма.

*<math> RC_{(C_{i},C_{j})}= \frac{S_{EC_{(C_{i},C_{j})}}}{\frac{|C_{i}|}{|C_{i}+C_{j}|}*S_{EC_{(C_{i})}}+\frac{|C_{i}|}{|C_{i}+C_{j}|}*S_{EC_{(C_{j})}}}</math> - относительное взаимное сходство пары кластеров <math>C_{i}, C{j}</math>. Определяется как абсолютное сходство между этой парой кластеров, нормализованное с учетом их внутреннего сходства<ref>http://studopedia.ru/7_41934_algoritm-dinamicheskoy-ierarhicheskoy-klasterizatsii-CHAMELEON.html</ref>.

'''Первый этап'''

На первом этапе, согласно графо-ориентированному подходу, происходит построение графа <math>G = (V, E)</math> на матрице сходства объектов по принципу k ближайших соседей. Две вершины такого графа соединяет ребро, если объект, соответствующий любой из этих вершин попадает в число k наиболее близких объектов для объекта, соответствующего другой вершине из данной пары.
[[Файл:Снимок chameleon 2.png|2000px|thumb|Рисунок 2. Объекты в пространстве - слева, граф по принципу 1-го ближайшего соседа - по центру, граф по принципу 3-х ближайших соседей - справа ]]

'''Второй этап'''

Алгоритм разделяет полученный граф на множество сравнительно малых подграфов <math>K= \{K_{i}\}</math>. Разделение происходит последовательно. На каждом шаге выбирается подграф, содержащий наибольшее число вершин. Этот граф разделяется на два подграфа так, что разделитель ребер графа минимален и каждый из получаемых подграфов содержит не менее 25 % вершин исходного графа. Процесс разделения останавливается, когда наибольший подграф содержит меньше некоторого заданного числа вершин. Обычно величина этого параметра задается равной значению от 1 до 5 % от числа объектов. Полученное множество связных графов считается множеством начальных кластеров, на котором требуется провести последовательное иерархическое объединение.

'''Третий этап'''

Третий этап заключается в итеративном преобразовании множества подграфов <math>K= \{K_{i}\}</math> в множество кластеров <math>C = \{C_{i}\}</math>. Алгоритм осуществляет агломеративную иерархическую кластеризацию на основании показателей <math>EC_{(C_{i},C_{j})}</math>, <math>S_{EC_{(C_{i},C_{j})}}</math>, <math>RI_{(C_{i},C_{j})} </math>, <math> RC_{(C_{i},C_{j})}</math>. Существует две стратегии анализа показателей сходства. Первая подразумевает наличие некоторых пороговых значений <math>T_{RI}</math> и <math>T_{RC}</math>. В соответствии с этой стратегией, алгоритм для каждого кластера <math>C_{i}</math> проверяет, отвечают ли смежные (наиболее близкие) ему кластеры условиям:

*<math>RI_{(C_{i},C_{j})} \geqslant T_{RI}</math>

*<math>RC_{(C_{i},C_{j})} \geqslant T_{RC}</math>

Если более одного смежного кластера отвечает этим условиям, то алгоритм выбирает для объединения наиболее связный кластер (граф), то есть такой кластер <math>C_{j}</math>, с которым у кластера <math>C_{i}</math> получается наибольшая абсолютная взаимная связность. По завершению прохода по всем кластерам, созданные таким образом пары объединяются. Параметры <math>T_{RI}</math> и <math>T_{RC}</math> могут использоваться для изменения характеристик получаемых кластеров.

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

<math>RI_{(C_{i},C_{j})}*RC_{(C_{i},C_{j})}^\alpha</math>,

где <math>\alpha</math> выбирается пользователем. Если <math>\alpha > 1 </math>, то алгоритм придает большее значение относительному взаимному сходству, а если <math>\alpha < 1 </math>, то большее значение имеет относительная взаимная связность.

''Вычисляемые данные'':

<math>U = (u_1, u_2, ..., u_n)</math> - n-мерный вектор, где <math>u_i \in N_{[C]}</math> - порядковый номер кластера, к которому принадлежит вершина i исходного множества V.

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

Алгоритм имеет три вычислительных ядра, по одному на каждый этап.

На первом этапе вычислительным ядром является процесс нахождения <math>k</math> ближайших соседей для каждой вершины, который заключается в анализе матрицы расстояний.

На втором этапе вычислительным ядром является процесс поиска подходящего разбиения очередного подграфа на два графа с минимизацией разделителя ребер графа.

На третьем этапе вычислительным ядром является расчет величин <math>EC_{(C_{i},C_{j})}</math>, <math>S_{EC_{(C_{i},C_{j})}}</math>, <math>RI_{(C_{i},C_{j})} </math>, <math> RC_{(C_{i},C_{j})}</math> для каждой пары смежных кластеров.

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

Как уже рассказывалось ранее, алгоритм включает в себя три основных этапа, каждый из которых, по сути, является отдельным алгоритмом. Этапы выполняются последовательно относительно друг друга.

Макрооперация на первом этапе - процедура нахождения <math>k</math> ближайших соседей, на втором - процедура разбиения наибольшего подграфа на два графа, на третьем - процедура вычисления показателей сходства, на основе которых принимается решение о слиянии подграфов в кластер.

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

'''Первый этап'''
<source lang="cpp">
int n; //количество вершин
int k; //количество соседей
int A[n][n] //матрица расстояний
int D[k] //массив вершин-соседей
int E[n][n] //матрица ребер графа <math>G_{2} = (K, E_{2})</math>
for i=1 to n-1 do
{
for j=i+1 to n do
{
//заполняем массив вершин-соседей вставляя новые вершины, если они ближе, чем самая далекая из массива.
}
for j=0 to k do
{
//для каждой вершины соседа заполняем соответствующую ячейку из матрицы E[n][n] единицей
}

}
</source>

'''Второй этап'''

1. Все связные подграфы в отсортированном порядке помещаются в список;
2. Берем наибольший элемент списка, вычисляем количество его вершин. Если число вершин > l, то идем в пункт 3. Иначе в пункт 5;
3. Разбиваем подграф на два подграфа таким образом, чтобы разделитель ребер графа был минимален и каждый из получаемых подграфов содержал не менее 25 % вершин исходного графа;
4. Добавляем полученные элементы в список подграфов таким образом, чтобы список оставался отсортированным. Идем в пункт 2;
5. Нашли искомое множество подграфов math>K = \{K_{i}\}</math>;
6. Создаем и заполняем матрицу матрицу расстояний для графа <math>G_{2} = (K, E_{2})</math>. Получаем искомый набор рёбер <math>E_{2}</math>.

'''Третий этап'''

1. Заводим два массива: а) массив кластеров C, полученных на предыдущем этапе, б) массив объединений кластеров F, которые мы будем получать на этом этапе;
2. Берем следующий кластер <math>C_{i}</math> (на первом шаге - первый). Если все кластеры просмотрены, идем в пункт 6;
3. Берем следующий кластер <math>C_{j}, i<>j</math>. Если все кластеры просмотрены, то идем в пункт 2;
4. Проверяем смежность <math>C_{i}</math> и <math>C_{j}</math>. Если не смежны, то возвращаемся в пункт 3. Если смежны, идем в пункт 5;
5. Рассчитываем показатели <math>RI_{(C_{i},C_{j})}</math> и <math> RC_{(C_{i},C_{j})}</math>. Проверяем, удовлетворяют ли найденные значения условиям:
*<math>RI_{(C_{i},C_{j})} \geqslant T_{RI}</math>
*<math>RC_{(C_{i},C_{j})} \geqslant T_{RC}</math>
Если нет, то идем в пункт 3. Иначе если смежность пары кластеров выше, чем у предыдущих найденных, то <math>F_{i}=j</math>. Идем в пункт 3;
6. Если в списке F есть хотя бы одна пара кластеров для слияния, то выполняем слияние, обновляем массив кластеров и массив объединений кластеров. Идем в пункт 2.

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

1) Для построения графа на основе метода k ближайших соседей для n вершин требуется <math>O(n log(n))</math> операций <ref>J.H. Friedman, J.L. Bentley, and R.A. Finkel. An algorithm for ﬁnding best matches in logarithmic expected time. ACM Transactions on Mathematical Software, 3:209–226, 1977.</ref>; для наборов данных большой размерности эта величина составляет <math>O(n^2)</math> операций <ref>S. Berchtold, C. Bohm, D. Keim, and H.-P. Kriegel. Cost model for nearest neighbor search in high dimensional data space. In Proc. of Symposium on Principles of Database Systems, Tucson, Arizona, 1997.</ref>;

2) Для выделения множества сравнительно малых связных подграфов требуется <math>nm</math> операций, где <math>m</math> - количество подграфов, полученных на втором этапе алгоритма;

3) Формирование набора кластеров, на основе множества подграфов, полученных на предыдущем этапе, требует <math>m^2log(m)</math> операций.

Итого, для n вершин получаем последовательную сложность <math>O(n log(n)+nm+m^2log(m))</math>.

== Информационный граф ==
[[File:СК.png]]

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

Первый этап работы алгоритма можно распределить между <math>n</math> процессами. На вход каждому процессу подается своя вершина, далее происходит процедура поиска <math>k</math> ближайших соседей. Параллельная сложность составляет <math>O(n)</math>.

Второй и третий этапы можно распараллелить частично.

Второй этап распараллеливается путем подачи на вход свободному процессу очередного подграфа для разделения. Число итераций оценивается в <math>O(n log(n))</math>.

Третий этап делится на расчет показателей схожести и соединение подграфов в кластеры. Процесс расчета показателей можно распараллелить, подавая каждому процессу на вход пару подграфов. Сложность этого процесса оценивается как <math>m log(m)</math>. Соединение подграфов в кластеры выполняется последовательно, сложность процесса составляет <math>m^2 log(m)</math>

Таким образом получаем общую параллельную сложность алгоритма: <math>O(n+ n log(n) + m^2 log (m) + m log(m))</math>

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

1. Симметрическая матрица <math>A</math> расстояний между элементами данных размера <math>n\times n</math> с нулями на главной диагонали (<math>a_{ii}= 0, i = 1, \ldots, N</math>).

2. <math>k</math> - количество ближайших соседей для вершин (рекомендуемое значение <math>k</math> от 5 до 20 в зависимости от количества анализируемых объектов).

3. <math>l</math> - наименьшее число вершин, которое может содержать наибольший подкластер на 2-м этапе . Величина этого параметра варьируется от 1 до 5 % от общего числа объектов.

'''Объём входных данных'''

<math>\frac{n (n - 1)}{2}</math> (в силу симметричности и нулевой главной диагонали достаточно хранить только над/поддиагональные элементы).

'''Выходные данные'''

Вектор из <math>n</math> чисел <math>u_{1}, u_{2}, \ldots, u_{N}</math>, где <math>u_{i}</math> - целое число, соответствующее кластеру <math>i</math>-го объекта.

'''Объём выходных данных'''

<math>n</math>

== Свойства алгоритма ==
Соотношение последовательной и параллельной сложности на первом этапе является ''линейным'' для больших наборов данных и логарифмическим для n вершин. На втором этапе сложно оценить это соотношение - оно сильно зависит от параметров <math>k</math> и <math>l</math>. На третьем этапе соотношение равно <math>O(1)</math>;

Оценка ''вычислительной мощности'' выглядит следующим образом:

<math>O(1)</math> для 1-го этапа;

<math>O(\frac{nm}{n^2+m^2})</math> для 2-го этапа;

<math>O(\frac{m^2log(m)}{m^2+n})</math> для 3-го этапа;

Алгоритм является ''недетерминированным''. Хотя 1-й этап детерминирован, на 2-ом этапе могут быть найдены различные разбиения на подграфы, что повлияет и на итоговый результат работы алгоритма.

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

[[File:Масштабирование.png|1000px]]

== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Последовательная реализация алгоритма доступна по ссылке <ref>http://read.pudn.com/downloads36/sourcecode/math/115779/chameleon/chameleon.c__.htm</ref>.

CHAMELEON можно реализовать с использованием графовых библиотек METIS <ref>http://glaros.dtc.umn.edu/gkhome/metis/metis/overview
</ref>, hMETIS <ref>http://glaros.dtc.umn.edu/gkhome/metis/hmetis/overview</ref> и RANN <ref>https://cran.r-project.org/web/packages/RANN/index.html</ref>.

Существует исследование, связанное с реализацией CHAMELEON посредством технологии OpenMP, с которым можно ознакомиться здесь <ref>http://research.ijcaonline.org/volume79/number8/pxc3891600.pdf</ref>.

Параллельных реализаций алгоритма CHAMELEON не найдено.

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

Участник:ЕкатеринаКозырева/Алгоритм динамической иерархической кластеризации CHAMELEON

2016-11-20T13:50:35Z

ЕкатеринаКозырева: /* Масштабируемость алгоритма и его реализации */

{{algorithm
| name = Алгоритм динамической иерархической кластеризации CHAMELEON
| serial_complexity = <math>O(nm + n log n + m^2 log m)</math>
| input_data = <math>\frac{n (n - 1)}{2}</math>
| output_data = <math>n</math>
| pf_height = <math>O(n+ n log(n) + m^2 log (m) + m log(m))</math>
| pf_width = <math>O(n)</math>
}}

Автор описания [[Участник:ЕкатеринаКозырева|Е.А.Козырева]]
= Свойства и структура алгоритмов =

== Общее описание алгоритма ==
Алгоритм CHAMELEON был предложен в 1999 году тремя учеными из университета Миннесоты – George Karypis, Eui-Hong (Sam) Han и Vipin Kumar<ref>George Karypis, Eui-Hong (Sam) Han и Vipin Kumar, «Chameleon: Hierarchical Clustering Using Dynamic Modeling», 1999.</ref>.

Предназначен для решения задач кластеризации. Кластеризация (или кластерный анализ) — это задача разбиения множества объектов на группы, называемые кластерами. Внутри каждой группы должны оказаться «похожие» объекты, а объекты разных группы должны быть как можно более отличны.

CHAMELEON - это агломеративный иерархический алгоритм кластеризации, ключевой особенностью которого является то, что он учитывает и взаимную связность, и сходство при определении наиболее похожей пары подкластеров, основываясь на динамической модели. Это означает, что в процессе кластеризации два кластера объединяются, только если их относительная взаимная связность и относительное взаимное сходство являются высокими по отношению к внутренней взаимосвязанности кластеров и близости элементов внутри кластеров. Кроме того, CHAMELEON использует подход для моделирования степени взаимосвязанности и близости между каждой парой кластеров, который учитывает внутренние характеристики самих кластеров. Таким образом, он может автоматически адаптироваться к внутренним характеристикам объединяемых кластеров.

CHAMELEON находит кластеры в наборе данных с помощью трехфазного алгоритма. На первой фазе происходит построение графа, путём добавления рёбер по принципу k ближайших соседей. На второй фазе CHAMELEON группирует полученные элементы в множество относительно небольших подграфов. Во время третьей фазы применяется агломеративный иерархический алгоритм кластеризации, с помощью которого находятся естесственные кластеры путем многократного объединения подграфов, полученных на прошлом этапе.

[[File:Chameleon.png|1000px|thumb|center|Рисунок 1. Общая структура алгоритма CHAMELEON]]

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

''Исходные данные'':

* Множество из n точек <math>V= {v_{ij}}</math> в метрическом пространстве, которое задано симметрической матрицей расстояний <math>A</math> размера <math>n\times n</math>.
* <math>k</math> - количество ближайших соседей для вершин, <math>k \in N, k \leq n</math>.
* <math>l</math> - наименьшее число вершин, которое может содержать наибольший подграф на 2-м этапе, <math>l \in N, l \leq n</math>.

''Обозначения'':

* <math>G = (V, E)</math> - граф, полученный путём соединения каждой точки с её <math>k</math> ближайшими соседями.

* <math>K= \{K_{i}\}</math> - разбиение множества <math>V</math> на набор попарно непересекающихся связных подмножеств, полученное в результате выполнения второй фазы алгоритма.

* <math>G_{2} = (K, E_{2})</math> - взвешенный граф, вершинами которого являются получившиеся подграфы, а ребрами - количество ребер исходного графа, соединяющих соответствующие подграфы.

* <math>C = \{C_{i}\}</math> - итоговое разбиение множества вершин графа <math>G_{2}</math> на набор кластеров.

''Вспомогательные понятия''

*<math>EC_{(C_{i},C_{j})}</math> - абсолютная взаимная связность пары кластеров <math>C_{i}, C{j}</math>. Определяется как сумма весов ребер, соединяющих вершины, принадлежащие <math>C{i}</math> c вершинами из <math>C{j}</math>. Внутренняя связность <math>EC_{(C_{i},C_{i})}</math> вычисляется как сумма ребер, входящих в разделитель, разбивающий <math>C{i}</math> на два равных подграфа.

*<math>RI_{(C_{i},C_{j})} = \frac{|EC_{(C_{i},C_{j})}|}{(|EC_{C_{i}}|+|EC_{C_{j}}|)/2}</math> - относительная взаимная связность пары кластеров <math>C_{i}, C{j}</math>

*<math>S_{EC_{(C_{i},C_{j})}}</math> - абсолютное взаимное сходство пары кластеров <math>C_{i}, C{j}</math>. Подсчитывается как среднее сходство между соединенными вершинами, принадлежащими <math>C{i}</math> и <math>C{j}</math> соответственно. Соединения обусловлены разбиением общего графа, полученного на первом этапе алгоритма.

*<math> RC_{(C_{i},C_{j})}= \frac{S_{EC_{(C_{i},C_{j})}}}{\frac{|C_{i}|}{|C_{i}+C_{j}|}*S_{EC_{(C_{i})}}+\frac{|C_{i}|}{|C_{i}+C_{j}|}*S_{EC_{(C_{j})}}}</math> - относительное взаимное сходство пары кластеров <math>C_{i}, C{j}</math>. Определяется как абсолютное сходство между этой парой кластеров, нормализованное с учетом их внутреннего сходства<ref>http://studopedia.ru/7_41934_algoritm-dinamicheskoy-ierarhicheskoy-klasterizatsii-CHAMELEON.html</ref>.

'''Первый этап'''

На первом этапе, согласно графо-ориентированному подходу, происходит построение графа <math>G = (V, E)</math> на матрице сходства объектов по принципу k ближайших соседей. Две вершины такого графа соединяет ребро, если объект, соответствующий любой из этих вершин попадает в число k наиболее близких объектов для объекта, соответствующего другой вершине из данной пары.
[[Файл:Снимок chameleon 2.png|2000px|thumb|Рисунок 2. Объекты в пространстве - слева, граф по принципу 1-го ближайшего соседа - по центру, граф по принципу 3-х ближайших соседей - справа ]]

'''Второй этап'''

Алгоритм разделяет полученный граф на множество сравнительно малых подграфов <math>K= \{K_{i}\}</math>. Разделение происходит последовательно. На каждом шаге выбирается подграф, содержащий наибольшее число вершин. Этот граф разделяется на два подграфа так, что разделитель ребер графа минимален и каждый из получаемых подграфов содержит не менее 25 % вершин исходного графа. Процесс разделения останавливается, когда наибольший подграф содержит меньше некоторого заданного числа вершин. Обычно величина этого параметра задается равной значению от 1 до 5 % от числа объектов. Полученное множество связных графов считается множеством начальных кластеров, на котором требуется провести последовательное иерархическое объединение.

'''Третий этап'''

Третий этап заключается в итеративном преобразовании множества подграфов <math>K= \{K_{i}\}</math> в множество кластеров <math>C = \{C_{i}\}</math>. Алгоритм осуществляет агломеративную иерархическую кластеризацию на основании показателей <math>EC_{(C_{i},C_{j})}</math>, <math>S_{EC_{(C_{i},C_{j})}}</math>, <math>RI_{(C_{i},C_{j})} </math>, <math> RC_{(C_{i},C_{j})}</math>. Существует две стратегии анализа показателей сходства. Первая подразумевает наличие некоторых пороговых значений <math>T_{RI}</math> и <math>T_{RC}</math>. В соответствии с этой стратегией, алгоритм для каждого кластера <math>C_{i}</math> проверяет, отвечают ли смежные (наиболее близкие) ему кластеры условиям:

*<math>RI_{(C_{i},C_{j})} \geqslant T_{RI}</math>

*<math>RC_{(C_{i},C_{j})} \geqslant T_{RC}</math>

Если более одного смежного кластера отвечает этим условиям, то алгоритм выбирает для объединения наиболее связный кластер (граф), то есть такой кластер <math>C_{j}</math>, с которым у кластера <math>C_{i}</math> получается наибольшая абсолютная взаимная связность. По завершению прохода по всем кластерам, созданные таким образом пары объединяются. Параметры <math>T_{RI}</math> и <math>T_{RC}</math> могут использоваться для изменения характеристик получаемых кластеров.

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

<math>RI_{(C_{i},C_{j})}*RC_{(C_{i},C_{j})}^\alpha</math>,

где <math>\alpha</math> выбирается пользователем. Если <math>\alpha > 1 </math>, то алгоритм придает большее значение относительному взаимному сходству, а если <math>\alpha < 1 </math>, то большее значение имеет относительная взаимная связность.

''Вычисляемые данные'':

<math>U = (u_1, u_2, ..., u_n)</math> - n-мерный вектор, где <math>u_i \in N_{[C]}</math> - порядковый номер кластера, к которому принадлежит вершина i исходного множества V.

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

Алгоритм имеет три вычислительных ядра, по одному на каждый этап.

На первом этапе вычислительным ядром является процесс нахождения <math>k</math> ближайших соседей для каждой вершины, который заключается в анализе матрицы расстояний.

На втором этапе вычислительным ядром является процесс поиска подходящего разбиения очередного подграфа на два графа с минимизацией разделителя ребер графа.

На третьем этапе вычислительным ядром является расчет величин <math>EC_{(C_{i},C_{j})}</math>, <math>S_{EC_{(C_{i},C_{j})}}</math>, <math>RI_{(C_{i},C_{j})} </math>, <math> RC_{(C_{i},C_{j})}</math> для каждой пары смежных кластеров.

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

Как уже рассказывалось ранее, алгоритм включает в себя три основных этапа, каждый из которых, по сути, является отдельным алгоритмом. Этапы выполняются последовательно относительно друг друга.

Макрооперация на первом этапе - процедура нахождения <math>k</math> ближайших соседей, на втором - процедура разбиения наибольшего подграфа на два графа, на третьем - процедура вычисления показателей сходства, на основе которых принимается решение о слиянии подграфов в кластер.

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

'''Первый этап'''
<source lang="cpp">
int n; //количество вершин
int k; //количество соседей
int A[n][n] //матрица расстояний
int D[k] //массив вершин-соседей
int E[n][n] //матрица ребер графа <math>G_{2} = (K, E_{2})</math>
for i=1 to n-1 do
{
for j=i+1 to n do
{
//заполняем массив вершин-соседей вставляя новые вершины, если они ближе, чем самая далекая из массива.
}
for j=0 to k do
{
//для каждой вершины соседа заполняем соответствующую ячейку из матрицы E[n][n] единицей
}

}
</source>

'''Второй этап'''

1. Все связные подграфы в отсортированном порядке помещаются в список;
2. Берем наибольший элемент списка, вычисляем количество его вершин. Если число вершин > l, то идем в пункт 3. Иначе в пункт 5;
3. Разбиваем подграф на два подграфа таким образом, чтобы разделитель ребер графа был минимален и каждый из получаемых подграфов содержал не менее 25 % вершин исходного графа;
4. Добавляем полученные элементы в список подграфов таким образом, чтобы список оставался отсортированным. Идем в пункт 2;
5. Нашли искомое множество подграфов math>K = \{K_{i}\}</math>;
6. Создаем и заполняем матрицу матрицу расстояний для графа <math>G_{2} = (K, E_{2})</math>. Получаем искомый набор рёбер <math>E_{2}</math>.

'''Третий этап'''

1. Заводим два массива: а) массив кластеров C, полученных на предыдущем этапе, б) массив объединений кластеров F, которые мы будем получать на этом этапе;
2. Берем следующий кластер <math>C_{i}</math> (на первом шаге - первый). Если все кластеры просмотрены, идем в пункт 6;
3. Берем следующий кластер <math>C_{j}, i<>j</math>. Если все кластеры просмотрены, то идем в пункт 2;
4. Проверяем смежность <math>C_{i}</math> и <math>C_{j}</math>. Если не смежны, то возвращаемся в пункт 3. Если смежны, идем в пункт 5;
5. Рассчитываем показатели <math>RI_{(C_{i},C_{j})}</math> и <math> RC_{(C_{i},C_{j})}</math>. Проверяем, удовлетворяют ли найденные значения условиям:
*<math>RI_{(C_{i},C_{j})} \geqslant T_{RI}</math>
*<math>RC_{(C_{i},C_{j})} \geqslant T_{RC}</math>
Если нет, то идем в пункт 3. Иначе если смежность пары кластеров выше, чем у предыдущих найденных, то <math>F_{i}=j</math>. Идем в пункт 3;
6. Если в списке F есть хотя бы одна пара кластеров для слияния, то выполняем слияние, обновляем массив кластеров и массив объединений кластеров. Идем в пункт 2.

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

1) Для построения графа на основе метода k ближайших соседей для n вершин требуется <math>O(n log(n))</math> операций <ref>J.H. Friedman, J.L. Bentley, and R.A. Finkel. An algorithm for ﬁnding best matches in logarithmic expected time. ACM Transactions on Mathematical Software, 3:209–226, 1977.</ref>; для наборов данных большой размерности эта величина составляет <math>O(n^2)</math> операций <ref>S. Berchtold, C. Bohm, D. Keim, and H.-P. Kriegel. Cost model for nearest neighbor search in high dimensional data space. In Proc. of Symposium on Principles of Database Systems, Tucson, Arizona, 1997.</ref>;

2) Для выделения множества сравнительно малых связных подграфов требуется <math>nm</math> операций, где <math>m</math> - количество подграфов, полученных на втором этапе алгоритма;

3) Формирование набора кластеров, на основе множества подграфов, полученных на предыдущем этапе, требует <math>m^2log(m)</math> операций.

Итого, для n вершин получаем последовательную сложность <math>O(n log(n)+nm+m^2log(m))</math>.

== Информационный граф ==
[[File:СК.png]]

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

Первый этап работы алгоритма можно распределить между <math>n</math> процессами. На вход каждому процессу подается своя вершина, далее происходит процедура поиска <math>k</math> ближайших соседей. Параллельная сложность составляет <math>O(n)</math>.

Второй и третий этапы можно распараллелить частично.

Второй этап распараллеливается путем подачи на вход свободному процессу очередного подграфа для разделения. Число итераций оценивается в <math>O(n log(n))</math>.

Третий этап делится на расчет показателей схожести и соединение подграфов в кластеры. Процесс расчета показателей можно распараллелить, подавая каждому процессу на вход пару подграфов. Сложность этого процесса оценивается как <math>m log(m)</math>. Соединение подграфов в кластеры выполняется последовательно, сложность процесса составляет <math>m^2 log(m)</math>

Таким образом получаем общую параллельную сложность алгоритма: <math>O(n+ n log(n) + m^2 log (m) + m log(m))</math>

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

1. Симметрическая матрица <math>A</math> расстояний между элементами данных размера <math>n\times n</math> с нулями на главной диагонали (<math>a_{ii}= 0, i = 1, \ldots, N</math>).

2. <math>k</math> - количество ближайших соседей для вершин (рекомендуемое значение <math>k</math> от 5 до 20 в зависимости от количества анализируемых объектов).

3. <math>l</math> - наименьшее число вершин, которое может содержать наибольший подкластер на 2-м этапе . Величина этого параметра варьируется от 1 до 5 % от общего числа объектов.

'''Объём входных данных'''

<math>\frac{n (n - 1)}{2}</math> (в силу симметричности и нулевой главной диагонали достаточно хранить только над/поддиагональные элементы).

'''Выходные данные'''

Вектор из <math>n</math> чисел <math>u_{1}, u_{2}, \ldots, u_{N}</math>, где <math>u_{i}</math> - целое число, соответствующее кластеру <math>i</math>-го объекта.

'''Объём выходных данных'''

<math>n</math>

== Свойства алгоритма ==
Соотношение последовательной и параллельной сложности на первом этапе является ''линейным'' для больших наборов данных и логарифмическим для n вершин. На втором этапе сложно оценить это соотношение - оно сильно зависит от параметров <math>k</math> и <math>l</math>. На третьем этапе соотношение равно <math>O(1)</math>;

Оценка ''вычислительной мощности'' выглядит следующим образом:

<math>O(1)</math> для 1-го этапа;

<math>O(\frac{nm}{n^2+m^2})</math> для 2-го этапа;

<math>O(\frac{m^2log(m)}{m^2+n})</math> для 3-го этапа;

Алгоритм является ''недетерминированным''. Хотя 1-й этап детерминирован, на 2-ом этапе могут быть найдены различные разбиения на подграфы, что повлияет и на итоговый результат работы алгоритма.

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

[[File:Масштабирование.png|1000px|thumb|center]]

== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Последовательная реализация алгоритма доступна по ссылке <ref>http://read.pudn.com/downloads36/sourcecode/math/115779/chameleon/chameleon.c__.htm</ref>.

CHAMELEON можно реализовать с использованием графовых библиотек METIS <ref>http://glaros.dtc.umn.edu/gkhome/metis/metis/overview
</ref>, hMETIS <ref>http://glaros.dtc.umn.edu/gkhome/metis/hmetis/overview</ref> и RANN <ref>https://cran.r-project.org/web/packages/RANN/index.html</ref>.

Существует исследование, связанное с реализацией CHAMELEON посредством технологии OpenMP, с которым можно ознакомиться здесь <ref>http://research.ijcaonline.org/volume79/number8/pxc3891600.pdf</ref>.

Параллельных реализаций алгоритма CHAMELEON не найдено.

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

Участник:ЕкатеринаКозырева/Алгоритм динамической иерархической кластеризации CHAMELEON

2016-11-15T19:10:26Z

ЕкатеринаКозырева: /* Существующие реализации алгоритма */

{{Assignment|Algoman}}

{{algorithm
| name = Алгоритм динамической иерархической кластеризации CHAMELEON
| serial_complexity = <math>O(nm + n log n + m^2 log m)</math>
| input_data = <math>\frac{n (n - 1)}{2}</math>
| output_data = <math>n</math>
| pf_height = <math>O(n+ n log(n) + m^2 log (m) + m log(m))</math>
| pf_width = <math>O(n)</math>
}}

Автор описания [[Участник:ЕкатеринаКозырева|Е.А.Козырева]]
= Свойства и структура алгоритмов =

== Общее описание алгоритма ==
Алгоритм CHAMELEON был предложен в 1999 году тремя учеными из университета Миннесоты – George Karypis, Eui-Hong (Sam) Han и Vipin Kumar<ref>George Karypis, Eui-Hong (Sam) Han и Vipin Kumar, «Chameleon: Hierarchical Clustering Using Dynamic Modeling», 1999.</ref>.

Предназначен для решения задач кластеризации. Кластеризация (или кластерный анализ) — это задача разбиения множества объектов на группы, называемые кластерами. Внутри каждой группы должны оказаться «похожие» объекты, а объекты разных группы должны быть как можно более отличны.

CHAMELEON - это агломеративный иерархический алгоритм кластеризации, ключевой особенностью которого является то, что он учитывает и взаимную связность, и сходство при определении наиболее похожей пары подкластеров, основываясь на динамической модели. Это означает, что в процессе кластеризации два кластера объединяются, только если их относительная взаимная связность и относительное взаимное сходство являются высокими по отношению к внутренней взаимосвязанности кластеров и близости элементов внутри кластеров. Кроме того, CHAMELEON использует подход для моделирования степени взаимосвязанности и близости между каждой парой кластеров, который учитывает внутренние характеристики самих кластеров. Таким образом, он может автоматически адаптироваться к внутренним характеристикам объединяемых кластеров.

CHAMELEON находит кластеры в наборе данных с помощью трехфазного алгоритма. На первой фазе происходит построение графа, путём добавления рёбер по принципу k ближайших соседей. На второй фазе CHAMELEON группирует полученные элементы в множество относительно небольших подграфов. Во время третьей фазы применяется агломеративный иерархический алгоритм кластеризации, с помощью которого находятся естесственные кластеры путем многократного объединения подграфов, полученных на прошлом этапе.

[[File:Chameleon.png|1000px|thumb|center|Рисунок 1. Общая структура алгоритма CHAMELEON]]

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

''Исходные данные'':

* Множество из n точек <math>V= {v_{ij}}</math> в метрическом пространстве, которое задано симметрической матрицей расстояний <math>A</math> размера <math>n\times n</math>.
* <math>k</math> - количество ближайших соседей для вершин, <math>k \in N, k \leq n</math>.
* <math>l</math> - наименьшее число вершин, которое может содержать наибольший подграф на 2-м этапе, <math>l \in N, l \leq n</math>.

''Обозначения'':

* <math>G = (V, E)</math> - граф, полученный путём соединения каждой точки с её <math>k</math> ближайшими соседями.

* <math>K= \{K_{i}\}</math> - разбиение множества <math>V</math> на набор попарно непересекающихся связных подмножеств, полученное в результате выполнения второй фазы алгоритма.

* <math>G_{2} = (K, E_{2})</math> - взвешенный граф, вершинами которого являются получившиеся подграфы, а ребрами - количество ребер исходного графа, соединяющих соответствующие подграфы.

* <math>C = \{C_{i}\}</math> - итоговое разбиение множества вершин графа <math>G_{2}</math> на набор кластеров.

''Вспомогательные понятия''

*<math>EC_{(C_{i},C_{j})}</math> - абсолютная взаимная связность пары кластеров <math>C_{i}, C{j}</math>. Определяется как сумма весов ребер, соединяющих вершины, принадлежащие <math>C{i}</math> c вершинами из <math>C{j}</math>. Внутренняя связность <math>EC_{(C_{i},C_{i})}</math> вычисляется как сумма ребер, входящих в разделитель, разбивающий <math>C{i}</math> на два равных подграфа.

*<math>RI_{(C_{i},C_{j})} = \frac{|EC_{(C_{i},C_{j})}|}{(|EC_{C_{i}}|+|EC_{C_{j}}|)/2}</math> - относительная взаимная связность пары кластеров <math>C_{i}, C{j}</math>

*<math>S_{EC_{(C_{i},C_{j})}}</math> - абсолютное взаимное сходство пары кластеров <math>C_{i}, C{j}</math>. Подсчитывается как среднее сходство между соединенными вершинами, принадлежащими <math>C{i}</math> и <math>C{j}</math> соответственно. Соединения обусловлены разбиением общего графа, полученного на первом этапе алгоритма.

*<math> RC_{(C_{i},C_{j})}= \frac{S_{EC_{(C_{i},C_{j})}}}{\frac{|C_{i}|}{|C_{i}+C_{j}|}*S_{EC_{(C_{i})}}+\frac{|C_{i}|}{|C_{i}+C_{j}|}*S_{EC_{(C_{j})}}}</math> - относительное взаимное сходство пары кластеров <math>C_{i}, C{j}</math>. Определяется как абсолютное сходство между этой парой кластеров, нормализованное с учетом их внутреннего сходства<ref>http://studopedia.ru/7_41934_algoritm-dinamicheskoy-ierarhicheskoy-klasterizatsii-CHAMELEON.html</ref>.

'''Первый этап'''

На первом этапе, согласно графо-ориентированному подходу, происходит построение графа <math>G = (V, E)</math> на матрице сходства объектов по принципу k ближайших соседей. Две вершины такого графа соединяет ребро, если объект, соответствующий любой из этих вершин попадает в число k наиболее близких объектов для объекта, соответствующего другой вершине из данной пары.
[[Файл:Снимок chameleon 2.png|2000px|thumb|Рисунок 2. Объекты в пространстве - слева, граф по принципу 1-го ближайшего соседа - по центру, граф по принципу 3-х ближайших соседей - справа ]]

'''Второй этап'''

Алгоритм разделяет полученный граф на множество сравнительно малых подграфов <math>K= \{K_{i}\}</math>. Разделение происходит последовательно. На каждом шаге выбирается подграф, содержащий наибольшее число вершин. Этот граф разделяется на два подграфа так, что разделитель ребер графа минимален и каждый из получаемых подграфов содержит не менее 25 % вершин исходного графа. Процесс разделения останавливается, когда наибольший подграф содержит меньше некоторого заданного числа вершин. Обычно величина этого параметра задается равной значению от 1 до 5 % от числа объектов. Полученное множество связных графов считается множеством начальных кластеров, на котором требуется провести последовательное иерархическое объединение.

'''Третий этап'''

Третий этап заключается в итеративном преобразовании множества подграфов <math>K= \{K_{i}\}</math> в множество кластеров <math>C = \{C_{i}\}</math>. Алгоритм осуществляет агломеративную иерархическую кластеризацию на основании показателей <math>EC_{(C_{i},C_{j})}</math>, <math>S_{EC_{(C_{i},C_{j})}}</math>, <math>RI_{(C_{i},C_{j})} </math>, <math> RC_{(C_{i},C_{j})}</math>. Существует две стратегии анализа показателей сходства. Первая подразумевает наличие некоторых пороговых значений <math>T_{RI}</math> и <math>T_{RC}</math>. В соответствии с этой стратегией, алгоритм для каждого кластера <math>C_{i}</math> проверяет, отвечают ли смежные (наиболее близкие) ему кластеры условиям:

*<math>RI_{(C_{i},C_{j})} \geqslant T_{RI}</math>

*<math>RC_{(C_{i},C_{j})} \geqslant T_{RC}</math>

Если более одного смежного кластера отвечает этим условиям, то алгоритм выбирает для объединения наиболее связный кластер (граф), то есть такой кластер <math>C_{j}</math>, с которым у кластера <math>C_{i}</math> получается наибольшая абсолютная взаимная связность. По завершению прохода по всем кластерам, созданные таким образом пары объединяются. Параметры <math>T_{RI}</math> и <math>T_{RC}</math> могут использоваться для изменения характеристик получаемых кластеров.

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

<math>RI_{(C_{i},C_{j})}*RC_{(C_{i},C_{j})}^\alpha</math>,

где <math>\alpha</math> выбирается пользователем. Если <math>\alpha > 1 </math>, то алгоритм придает большее значение относительному взаимному сходству, а если <math>\alpha < 1 </math>, то большее значение имеет относительная взаимная связность.

''Вычисляемые данные'':

<math>U = (u_1, u_2, ..., u_n)</math> - n-мерный вектор, где <math>u_i \in N_{[C]}</math> - порядковый номер кластера, к которому принадлежит вершина i исходного множества V.

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

Алгоритм имеет три вычислительных ядра, по одному на каждый этап.

На первом этапе вычислительным ядром является процесс нахождения <math>k</math> ближайших соседей для каждой вершины, который заключается в анализе матрицы расстояний.

На втором этапе вычислительным ядром является процесс поиска подходящего разбиения очередного подграфа на два графа с минимизацией разделителя ребер графа.

На третьем этапе вычислительным ядром является расчет величин <math>EC_{(C_{i},C_{j})}</math>, <math>S_{EC_{(C_{i},C_{j})}}</math>, <math>RI_{(C_{i},C_{j})} </math>, <math> RC_{(C_{i},C_{j})}</math> для каждой пары смежных кластеров.

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

Как уже рассказывалось ранее, алгоритм включает в себя три основных этапа, каждый из которых, по сути, является отдельным алгоритмом. Этапы выполняются последовательно относительно друг друга.

Макрооперация на первом этапе - процедура нахождения <math>k</math> ближайших соседей, на втором - процедура разбиения наибольшего подграфа на два графа, на третьем - процедура вычисления показателей сходства, на основе которых принимается решение о слиянии подграфов в кластер.

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

'''Первый этап'''
<source lang="cpp">
int n; //количество вершин
int k; //количество соседей
int A[n][n] //матрица расстояний
int D[k] //массив вершин-соседей
int E[n][n] //матрица ребер графа <math>G_{2} = (K, E_{2})</math>
for i=1 to n-1 do
{
for j=i+1 to n do
{
//заполняем массив вершин-соседей вставляя новые вершины, если они ближе, чем самая далекая из массива.
}
for j=0 to k do
{
//для каждой вершины соседа заполняем соответствующую ячейку из матрицы E[n][n] единицей
}

}
</source>

'''Второй этап'''

1. Все связные подграфы в отсортированном порядке помещаются в список;
2. Берем наибольший элемент списка, вычисляем количество его вершин. Если число вершин > l, то идем в пункт 3. Иначе в пункт 5;
3. Разбиваем подграф на два подграфа таким образом, чтобы разделитель ребер графа был минимален и каждый из получаемых подграфов содержал не менее 25 % вершин исходного графа;
4. Добавляем полученные элементы в список подграфов таким образом, чтобы список оставался отсортированным. Идем в пункт 2;
5. Нашли искомое множество подграфов math>K = \{K_{i}\}</math>;
6. Создаем и заполняем матрицу матрицу расстояний для графа <math>G_{2} = (K, E_{2})</math>. Получаем искомый набор рёбер <math>E_{2}</math>.

'''Третий этап'''

1. Заводим два массива: а) массив кластеров C, полученных на предыдущем этапе, б) массив объединений кластеров F, которые мы будем получать на этом этапе;
2. Берем следующий кластер <math>C_{i}</math> (на первом шаге - первый). Если все кластеры просмотрены, идем в пункт 6;
3. Берем следующий кластер <math>C_{j}, i<>j</math>. Если все кластеры просмотрены, то идем в пункт 2;
4. Проверяем смежность <math>C_{i}</math> и <math>C_{j}</math>. Если не смежны, то возвращаемся в пункт 3. Если смежны, идем в пункт 5;
5. Рассчитываем показатели <math>RI_{(C_{i},C_{j})}</math> и <math> RC_{(C_{i},C_{j})}</math>. Проверяем, удовлетворяют ли найденные значения условиям:
*<math>RI_{(C_{i},C_{j})} \geqslant T_{RI}</math>
*<math>RC_{(C_{i},C_{j})} \geqslant T_{RC}</math>
Если нет, то идем в пункт 3. Иначе если смежность пары кластеров выше, чем у предыдущих найденных, то <math>F_{i}=j</math>. Идем в пункт 3;
6. Если в списке F есть хотя бы одна пара кластеров для слияния, то выполняем слияние, обновляем массив кластеров и массив объединений кластеров. Идем в пункт 2.

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

1) Для построения графа на основе метода k ближайших соседей для n вершин требуется <math>O(n log(n))</math> операций <ref>J.H. Friedman, J.L. Bentley, and R.A. Finkel. An algorithm for ﬁnding best matches in logarithmic expected time. ACM Transactions on Mathematical Software, 3:209–226, 1977.</ref>; для наборов данных большой размерности эта величина составляет <math>O(n^2)</math> операций <ref>S. Berchtold, C. Bohm, D. Keim, and H.-P. Kriegel. Cost model for nearest neighbor search in high dimensional data space. In Proc. of Symposium on Principles of Database Systems, Tucson, Arizona, 1997.</ref>;

2) Для выделения множества сравнительно малых связных подграфов требуется <math>nm</math> операций, где <math>m</math> - количество подграфов, полученных на втором этапе алгоритма;

3) Формирование набора кластеров, на основе множества подграфов, полученных на предыдущем этапе, требует <math>m^2log(m)</math> операций.

Итого, для n вершин получаем последовательную сложность <math>O(n log(n)+nm+m^2log(m))</math>.

== Информационный граф ==
[[File:СК.png]]

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

Первый этап работы алгоритма можно распределить между <math>n</math> процессами. На вход каждому процессу подается своя вершина, далее происходит процедура поиска <math>k</math> ближайших соседей. Параллельная сложность составляет <math>O(n)</math>.

Второй и третий этапы можно распараллелить частично.

Второй этап распараллеливается путем подачи на вход свободному процессу очередного подграфа для разделения. Число итераций оценивается в <math>O(n log(n))</math>.

Третий этап делится на расчет показателей схожести и соединение подграфов в кластеры. Процесс расчета показателей можно распараллелить, подавая каждому процессу на вход пару подграфов. Сложность этого процесса оценивается как <math>m log(m)</math>. Соединение подграфов в кластеры выполняется последовательно, сложность процесса составляет <math>m^2 log(m)</math>

Таким образом получаем общую параллельную сложность алгоритма: <math>O(n+ n log(n) + m^2 log (m) + m log(m))</math>

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

1. Симметрическая матрица <math>A</math> расстояний между элементами данных размера <math>n\times n</math> с нулями на главной диагонали (<math>a_{ii}= 0, i = 1, \ldots, N</math>).

2. <math>k</math> - количество ближайших соседей для вершин (рекомендуемое значение <math>k</math> от 5 до 20 в зависимости от количества анализируемых объектов).

3. <math>l</math> - наименьшее число вершин, которое может содержать наибольший подкластер на 2-м этапе . Величина этого параметра варьируется от 1 до 5 % от общего числа объектов.

'''Объём входных данных'''

<math>\frac{n (n - 1)}{2}</math> (в силу симметричности и нулевой главной диагонали достаточно хранить только над/поддиагональные элементы).

'''Выходные данные'''

Вектор из <math>n</math> чисел <math>u_{1}, u_{2}, \ldots, u_{N}</math>, где <math>u_{i}</math> - целое число, соответствующее кластеру <math>i</math>-го объекта.

'''Объём выходных данных'''

<math>n</math>

== Свойства алгоритма ==
Соотношение последовательной и параллельной сложности на первом этапе является ''линейным'' для больших наборов данных и логарифмическим для n вершин. На втором этапе сложно оценить это соотношение - оно сильно зависит от параметров <math>k</math> и <math>l</math>. На третьем этапе соотношение равно <math>O(1)</math>;

Оценка ''вычислительной мощности'' выглядит следующим образом:

<math>O(1)</math> для 1-го этапа;

<math>O(\frac{nm}{n^2+m^2})</math> для 2-го этапа;

<math>O(\frac{m^2log(m)}{m^2+n})</math> для 3-го этапа;

Алгоритм является ''недетерминированным''. Хотя 1-й этап детерминирован, на 2-ом этапе могут быть найдены различные разбиения на подграфы, что повлияет и на итоговый результат работы алгоритма.

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

см. позднее

== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Последовательная реализация алгоритма доступна по ссылке <ref>http://read.pudn.com/downloads36/sourcecode/math/115779/chameleon/chameleon.c__.htm</ref>.

CHAMELEON можно реализовать с использованием графовых библиотек METIS <ref>http://glaros.dtc.umn.edu/gkhome/metis/metis/overview
</ref>, hMETIS <ref>http://glaros.dtc.umn.edu/gkhome/metis/hmetis/overview</ref> и RANN <ref>https://cran.r-project.org/web/packages/RANN/index.html</ref>.

Существует исследование, связанное с реализацией CHAMELEON посредством технологии OpenMP, с которым можно ознакомиться здесь <ref>http://research.ijcaonline.org/volume79/number8/pxc3891600.pdf</ref>.

Параллельных реализаций алгоритма CHAMELEON не найдено.

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

Участник:ЕкатеринаКозырева/Алгоритм динамической иерархической кластеризации CHAMELEON

2016-10-31T20:23:57Z

ЕкатеринаКозырева: /* Свойства алгоритма */

{{Assignment}}

{{algorithm
| name = Алгоритм динамической иерархической кластеризации CHAMELEON
| serial_complexity = <math>O(nm + n log n + m^2 log m)</math>
| input_data = <math>\frac{n (n - 1)}{2}</math>
| output_data = <math>n</math>
| pf_height = <math>O(n+ n log(n) + m^2 log (m) + m log(m))</math>
| pf_width = <math>O(n)</math>
}}

Автор описания [[Участник:ЕкатеринаКозырева|Е.А.Козырева]]
= Свойства и структура алгоритмов =

== Общее описание алгоритма ==
Алгоритм CHAMELEON был предложен в 1999 году тремя учеными из университета Миннесоты – George Karypis, Eui-Hong (Sam) Han и Vipin Kumar<ref>George Karypis, Eui-Hong (Sam) Han и Vipin Kumar, «Chameleon: Hierarchical Clustering Using Dynamic Modeling», 1999.</ref>.

Предназначен для решения задач кластеризации. Кластеризация (или кластерный анализ) — это задача разбиения множества объектов на группы, называемые кластерами. Внутри каждой группы должны оказаться «похожие» объекты, а объекты разных группы должны быть как можно более отличны.

CHAMELEON - это агломеративный иерархический алгоритм кластеризации, ключевой особенностью которого является то, что он учитывает и взаимную связность, и сходство при определении наиболее похожей пары подкластеров, основываясь на динамической модели. Это означает, что в процессе кластеризации два кластера объединяются, только если их относительная взаимная связность и относительное взаимное сходство являются высокими по отношению к внутренней взаимосвязанности кластеров и близости элементов внутри кластеров. Кроме того, CHAMELEON использует подход для моделирования степени взаимосвязанности и близости между каждой парой кластеров, который учитывает внутренние характеристики самих кластеров. Таким образом, он может автоматически адаптироваться к внутренним характеристикам объединяемых кластеров.

CHAMELEON находит кластеры в наборе данных с помощью трехфазного алгоритма. На первой фазе происходит построение графа, путём добавления рёбер по принципу k ближайших соседей. На второй фазе CHAMELEON группирует полученные элементы в множество относительно небольших подграфов. Во время третьей фазы применяется агломеративный иерархический алгоритм кластеризации, с помощью которого находятся естесственные кластеры путем многократного объединения подграфов, полученных на прошлом этапе.

[[File:Chameleon.png|1000px|thumb|center|Рисунок 1. Общая структура алгоритма CHAMELEON]]

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

''Исходные данные'':

* Множество из n точек <math>V= {v_{ij}}</math> в метрическом пространстве, которое задано симметрической матрицей расстояний <math>A</math> размера <math>n\times n</math>.
* <math>k</math> - количество ближайших соседей для вершин, <math>k \in N, k \leq n</math>.
* <math>l</math> - наименьшее число вершин, которое может содержать наибольший подграф на 2-м этапе, <math>l \in N, l \leq n</math>.

''Обозначения'':

* <math>G = (V, E)</math> - граф, полученный путём соединения каждой точки с её <math>k</math> ближайшими соседями.

* <math>K= \{K_{i}\}</math> - разбиение множества <math>V</math> на набор попарно непересекающихся связных подмножеств, полученное в результате выполнения второй фазы алгоритма.

* <math>G_{2} = (K, E_{2})</math> - взвешенный граф, вершинами которого являются получившиеся подграфы, а ребрами - количество ребер исходного графа, соединяющих соответствующие подграфы.

* <math>C = \{C_{i}\}</math> - итоговое разбиение множества вершин графа <math>G_{2}</math> на набор кластеров.

''Вспомогательные понятия''

*<math>EC_{(C_{i},C_{j})}</math> - абсолютная взаимная связность пары кластеров <math>C_{i}, C{j}</math>. Определяется как сумма весов ребер, соединяющих вершины, принадлежащие <math>C{i}</math> c вершинами из <math>C{j}</math>. Внутренняя связность <math>EC_{(C_{i},C_{i})}</math> вычисляется как сумма ребер, входящих в разделитель, разбивающий <math>C{i}</math> на два равных подграфа.

*<math>RI_{(C_{i},C_{j})} = \frac{|EC_{(C_{i},C_{j})}|}{(|EC_{C_{i}}|+|EC_{C_{j}}|)/2}</math> - относительная взаимная связность пары кластеров <math>C_{i}, C{j}</math>

*<math>S_{EC_{(C_{i},C_{j})}}</math> - абсолютное взаимное сходство пары кластеров <math>C_{i}, C{j}</math>. Подсчитывается как среднее сходство между соединенными вершинами, принадлежащими <math>C{i}</math> и <math>C{j}</math> соответственно. Соединения обусловлены разбиением общего графа, полученного на первом этапе алгоритма.

*<math> RC_{(C_{i},C_{j})}= \frac{S_{EC_{(C_{i},C_{j})}}}{\frac{|C_{i}|}{|C_{i}+C_{j}|}*S_{EC_{(C_{i})}}+\frac{|C_{i}|}{|C_{i}+C_{j}|}*S_{EC_{(C_{j})}}}</math> - относительное взаимное сходство пары кластеров <math>C_{i}, C{j}</math>. Определяется как абсолютное сходство между этой парой кластеров, нормализованное с учетом их внутреннего сходства<ref>http://studopedia.ru/7_41934_algoritm-dinamicheskoy-ierarhicheskoy-klasterizatsii-CHAMELEON.html</ref>.

'''Первый этап'''

На первом этапе, согласно графо-ориентированному подходу, происходит построение графа <math>G = (V, E)</math> на матрице сходства объектов по принципу k ближайших соседей. Две вершины такого графа соединяет ребро, если объект, соответствующий любой из этих вершин попадает в число k наиболее близких объектов для объекта, соответствующего другой вершине из данной пары.
[[Файл:Снимок chameleon 2.png|2000px|thumb|Рисунок 2. Объекты в пространстве - слева, граф по принципу 1-го ближайшего соседа - по центру, граф по принципу 3-х ближайших соседей - справа ]]

'''Второй этап'''

Алгоритм разделяет полученный граф на множество сравнительно малых подграфов <math>K= \{K_{i}\}</math>. Разделение происходит последовательно. На каждом шаге выбирается подграф, содержащий наибольшее число вершин. Этот граф разделяется на два подграфа так, что разделитель ребер графа минимален и каждый из получаемых подграфов содержит не менее 25 % вершин исходного графа. Процесс разделения останавливается, когда наибольший подграф содержит меньше некоторого заданного числа вершин. Обычно величина этого параметра задается равной значению от 1 до 5 % от числа объектов. Полученное множество связных графов считается множеством начальных кластеров, на котором требуется провести последовательное иерархическое объединение.

'''Третий этап'''

Третий этап заключается в итеративном преобразовании множества подграфов <math>K= \{K_{i}\}</math> в множество кластеров <math>C = \{C_{i}\}</math>. Алгоритм осуществляет агломеративную иерархическую кластеризацию на основании показателей <math>EC_{(C_{i},C_{j})}</math>, <math>S_{EC_{(C_{i},C_{j})}}</math>, <math>RI_{(C_{i},C_{j})} </math>, <math> RC_{(C_{i},C_{j})}</math>. Существует две стратегии анализа показателей сходства. Первая подразумевает наличие некоторых пороговых значений <math>T_{RI}</math> и <math>T_{RC}</math>. В соответствии с этой стратегией, алгоритм для каждого кластера <math>C_{i}</math> проверяет, отвечают ли смежные (наиболее близкие) ему кластеры условиям:

*<math>RI_{(C_{i},C_{j})} \geqslant T_{RI}</math>

*<math>RC_{(C_{i},C_{j})} \geqslant T_{RC}</math>

Если более одного смежного кластера отвечает этим условиям, то алгоритм выбирает для объединения наиболее связный кластер (граф), то есть такой кластер <math>C_{j}</math>, с которым у кластера <math>C_{i}</math> получается наибольшая абсолютная взаимная связность. По завершению прохода по всем кластерам, созданные таким образом пары объединяются. Параметры <math>T_{RI}</math> и <math>T_{RC}</math> могут использоваться для изменения характеристик получаемых кластеров.

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

<math>RI_{(C_{i},C_{j})}*RC_{(C_{i},C_{j})}^\alpha</math>,

где <math>\alpha</math> выбирается пользователем. Если <math>\alpha > 1 </math>, то алгоритм придает большее значение относительному взаимному сходству, а если <math>\alpha < 1 </math>, то большее значение имеет относительная взаимная связность.

''Вычисляемые данные'':

<math>U = (u_1, u_2, ..., u_n)</math> - n-мерный вектор, где <math>u_i \in N_{[C]}</math> - порядковый номер кластера, к которому принадлежит вершина i исходного множества V.

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

Алгоритм имеет три вычислительных ядра, по одному на каждый этап.

На первом этапе вычислительным ядром является процесс нахождения <math>k</math> ближайших соседей для каждой вершины, который заключается в анализе матрицы расстояний.

На втором этапе вычислительным ядром является процесс поиска подходящего разбиения очередного подграфа на два графа с минимизацией разделителя ребер графа.

На третьем этапе вычислительным ядром является расчет величин <math>EC_{(C_{i},C_{j})}</math>, <math>S_{EC_{(C_{i},C_{j})}}</math>, <math>RI_{(C_{i},C_{j})} </math>, <math> RC_{(C_{i},C_{j})}</math> для каждой пары смежных кластеров.

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

Как уже рассказывалось ранее, алгоритм включает в себя три основных этапа, каждый из которых, по сути, является отдельным алгоритмом. Этапы выполняются последовательно относительно друг друга.

Макрооперация на первом этапе - процедура нахождения <math>k</math> ближайших соседей, на втором - процедура разбиения наибольшего подграфа на два графа, на третьем - процедура вычисления показателей сходства, на основе которых принимается решение о слиянии подграфов в кластер.

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

'''Первый этап'''
<source lang="cpp">
int n; //количество вершин
int k; //количество соседей
int A[n][n] //матрица расстояний
int D[k] //массив вершин-соседей
int E[n][n] //матрица ребер графа <math>G_{2} = (K, E_{2})</math>
for i=1 to n-1 do
{
for j=i+1 to n do
{
//заполняем массив вершин-соседей вставляя новые вершины, если они ближе, чем самая далекая из массива.
}
for j=0 to k do
{
//для каждой вершины соседа заполняем соответствующую ячейку из матрицы E[n][n] единицей
}

}
</source>

'''Второй этап'''

1. Все связные подграфы в отсортированном порядке помещаются в список;
2. Берем наибольший элемент списка, вычисляем количество его вершин. Если число вершин > l, то идем в пункт 3. Иначе в пункт 5;
3. Разбиваем подграф на два подграфа таким образом, чтобы разделитель ребер графа был минимален и каждый из получаемых подграфов содержал не менее 25 % вершин исходного графа;
4. Добавляем полученные элементы в список подграфов таким образом, чтобы список оставался отсортированным. Идем в пункт 2;
5. Нашли искомое множество подграфов math>K = \{K_{i}\}</math>;
6. Создаем и заполняем матрицу матрицу расстояний для графа <math>G_{2} = (K, E_{2})</math>. Получаем искомый набор рёбер <math>E_{2}</math>.

'''Третий этап'''

1. Заводим два массива: а) массив кластеров C, полученных на предыдущем этапе, б) массив объединений кластеров F, которые мы будем получать на этом этапе;
2. Берем следующий кластер <math>C_{i}</math> (на первом шаге - первый). Если все кластеры просмотрены, идем в пункт 6;
3. Берем следующий кластер <math>C_{j}, i<>j</math>. Если все кластеры просмотрены, то идем в пункт 2;
4. Проверяем смежность <math>C_{i}</math> и <math>C_{j}</math>. Если не смежны, то возвращаемся в пункт 3. Если смежны, идем в пункт 5;
5. Рассчитываем показатели <math>RI_{(C_{i},C_{j})}</math> и <math> RC_{(C_{i},C_{j})}</math>. Проверяем, удовлетворяют ли найденные значения условиям:
*<math>RI_{(C_{i},C_{j})} \geqslant T_{RI}</math>
*<math>RC_{(C_{i},C_{j})} \geqslant T_{RC}</math>
Если нет, то идем в пункт 3. Иначе если смежность пары кластеров выше, чем у предыдущих найденных, то <math>F_{i}=j</math>. Идем в пункт 3;
6. Если в списке F есть хотя бы одна пара кластеров для слияния, то выполняем слияние, обновляем массив кластеров и массив объединений кластеров. Идем в пункт 2.

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

1) Для построения графа на основе метода k ближайших соседей для n вершин требуется <math>O(n log(n))</math> операций <ref>J.H. Friedman, J.L. Bentley, and R.A. Finkel. An algorithm for ﬁnding best matches in logarithmic expected time. ACM Transactions on Mathematical Software, 3:209–226, 1977.</ref>; для наборов данных большой размерности эта величина составляет <math>O(n^2)</math> операций <ref>S. Berchtold, C. Bohm, D. Keim, and H.-P. Kriegel. Cost model for nearest neighbor search in high dimensional data space. In Proc. of Symposium on Principles of Database Systems, Tucson, Arizona, 1997.</ref>;

2) Для выделения множества сравнительно малых связных подграфов требуется <math>nm</math> операций, где <math>m</math> - количество подграфов, полученных на втором этапе алгоритма;

3) Формирование набора кластеров, на основе множества подграфов, полученных на предыдущем этапе, требует <math>m^2log(m)</math> операций.

Итого, для n вершин получаем последовательную сложность <math>O(n log(n)+nm+m^2log(m))</math>.

== Информационный граф ==
[[File:СК.png]]

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

Первый этап работы алгоритма можно распределить между <math>n</math> процессами. На вход каждому процессу подается своя вершина, далее происходит процедура поиска <math>k</math> ближайших соседей. Параллельная сложность составляет <math>O(n)</math>.

Второй и третий этапы можно распараллелить частично.

Второй этап распараллеливается путем подачи на вход свободному процессу очередного подграфа для разделения. Число итераций оценивается в <math>O(n log(n))</math>.

Третий этап делится на расчет показателей схожести и соединение подграфов в кластеры. Процесс расчета показателей можно распараллелить, подавая каждому процессу на вход пару подграфов. Сложность этого процесса оценивается как <math>m log(m)</math>. Соединение подграфов в кластеры выполняется последовательно, сложность процесса составляет <math>m^2 log(m)</math>

Таким образом получаем общую параллельную сложность алгоритма: <math>O(n+ n log(n) + m^2 log (m) + m log(m))</math>

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

1. Симметрическая матрица <math>A</math> расстояний между элементами данных размера <math>n\times n</math> с нулями на главной диагонали (<math>a_{ii}= 0, i = 1, \ldots, N</math>).

2. <math>k</math> - количество ближайших соседей для вершин (рекомендуемое значение <math>k</math> от 5 до 20 в зависимости от количества анализируемых объектов).

3. <math>l</math> - наименьшее число вершин, которое может содержать наибольший подкластер на 2-м этапе . Величина этого параметра варьируется от 1 до 5 % от общего числа объектов.

'''Объём входных данных'''

<math>\frac{n (n - 1)}{2}</math> (в силу симметричности и нулевой главной диагонали достаточно хранить только над/поддиагональные элементы).

'''Выходные данные'''

Вектор из <math>n</math> чисел <math>u_{1}, u_{2}, \ldots, u_{N}</math>, где <math>u_{i}</math> - целое число, соответствующее кластеру <math>i</math>-го объекта.

'''Объём выходных данных'''

<math>n</math>

== Свойства алгоритма ==
Соотношение последовательной и параллельной сложности на первом этапе является ''линейным'' для больших наборов данных и логарифмическим для n вершин. На втором этапе сложно оценить это соотношение - оно сильно зависит от параметров <math>k</math> и <math>l</math>. На третьем этапе соотношение равно <math>O(1)</math>;

Оценка ''вычислительной мощности'' выглядит следующим образом:

<math>O(1)</math> для 1-го этапа;

<math>O(\frac{nm}{n^2+m^2})</math> для 2-го этапа;

<math>O(\frac{m^2log(m)}{m^2+n})</math> для 3-го этапа;

Алгоритм является ''недетерминированным''. Хотя 1-й этап детерминирован, на 2-ом этапе могут быть найдены различные разбиения на подграфы, что повлияет и на итоговый результат работы алгоритма.

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

см. позднее

== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Последовательная реализация алгоритма доступна по ссылке <ref>http://www.codeforge.com/article/192925</ref>.

CHAMELEON можно реализовать с использованием графовых библиотек METIS <ref>http://glaros.dtc.umn.edu/gkhome/metis/metis/overview
</ref>, hMETIS <ref>http://glaros.dtc.umn.edu/gkhome/metis/hmetis/overview</ref> и RANN <ref>https://cran.r-project.org/web/packages/RANN/index.html</ref>.

Существует исследование, связанное с реализацией CHAMELEON посредством технологии OpenMP, с которым можно ознакомиться здесь <ref>http://research.ijcaonline.org/volume79/number8/pxc3891600.pdf</ref>.

Параллельных реализаций алгоритма CHAMELEON не найдено.

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

Участник:ЕкатеринаКозырева/Алгоритм динамической иерархической кластеризации CHAMELEON

2016-10-31T19:50:39Z

ЕкатеринаКозырева:

{{Assignment}}

{{algorithm
| name = Алгоритм динамической иерархической кластеризации CHAMELEON
| serial_complexity = <math>O(nm + n log n + m^2 log m)</math>
| input_data = <math>\frac{n (n - 1)}{2}</math>
| output_data = <math>n</math>
| pf_height = <math>O(n+ n log(n) + m^2 log (m) + m log(m))</math>
| pf_width = <math>O(n)</math>
}}

Автор описания [[Участник:ЕкатеринаКозырева|Е.А.Козырева]]
= Свойства и структура алгоритмов =

== Общее описание алгоритма ==
Алгоритм CHAMELEON был предложен в 1999 году тремя учеными из университета Миннесоты – George Karypis, Eui-Hong (Sam) Han и Vipin Kumar<ref>George Karypis, Eui-Hong (Sam) Han и Vipin Kumar, «Chameleon: Hierarchical Clustering Using Dynamic Modeling», 1999.</ref>.

Предназначен для решения задач кластеризации. Кластеризация (или кластерный анализ) — это задача разбиения множества объектов на группы, называемые кластерами. Внутри каждой группы должны оказаться «похожие» объекты, а объекты разных группы должны быть как можно более отличны.

CHAMELEON - это агломеративный иерархический алгоритм кластеризации, ключевой особенностью которого является то, что он учитывает и взаимную связность, и сходство при определении наиболее похожей пары подкластеров, основываясь на динамической модели. Это означает, что в процессе кластеризации два кластера объединяются, только если их относительная взаимная связность и относительное взаимное сходство являются высокими по отношению к внутренней взаимосвязанности кластеров и близости элементов внутри кластеров. Кроме того, CHAMELEON использует подход для моделирования степени взаимосвязанности и близости между каждой парой кластеров, который учитывает внутренние характеристики самих кластеров. Таким образом, он может автоматически адаптироваться к внутренним характеристикам объединяемых кластеров.

CHAMELEON находит кластеры в наборе данных с помощью трехфазного алгоритма. На первой фазе происходит построение графа, путём добавления рёбер по принципу k ближайших соседей. На второй фазе CHAMELEON группирует полученные элементы в множество относительно небольших подграфов. Во время третьей фазы применяется агломеративный иерархический алгоритм кластеризации, с помощью которого находятся естесственные кластеры путем многократного объединения подграфов, полученных на прошлом этапе.

[[File:Chameleon.png|1000px|thumb|center|Рисунок 1. Общая структура алгоритма CHAMELEON]]

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

''Исходные данные'':

* Множество из n точек <math>V= {v_{ij}}</math> в метрическом пространстве, которое задано симметрической матрицей расстояний <math>A</math> размера <math>n\times n</math>.
* <math>k</math> - количество ближайших соседей для вершин, <math>k \in N, k \leq n</math>.
* <math>l</math> - наименьшее число вершин, которое может содержать наибольший подграф на 2-м этапе, <math>l \in N, l \leq n</math>.

''Обозначения'':

* <math>G = (V, E)</math> - граф, полученный путём соединения каждой точки с её <math>k</math> ближайшими соседями.

* <math>K= \{K_{i}\}</math> - разбиение множества <math>V</math> на набор попарно непересекающихся связных подмножеств, полученное в результате выполнения второй фазы алгоритма.

* <math>G_{2} = (K, E_{2})</math> - взвешенный граф, вершинами которого являются получившиеся подграфы, а ребрами - количество ребер исходного графа, соединяющих соответствующие подграфы.

* <math>C = \{C_{i}\}</math> - итоговое разбиение множества вершин графа <math>G_{2}</math> на набор кластеров.

''Вспомогательные понятия''

*<math>EC_{(C_{i},C_{j})}</math> - абсолютная взаимная связность пары кластеров <math>C_{i}, C{j}</math>. Определяется как сумма весов ребер, соединяющих вершины, принадлежащие <math>C{i}</math> c вершинами из <math>C{j}</math>. Внутренняя связность <math>EC_{(C_{i},C_{i})}</math> вычисляется как сумма ребер, входящих в разделитель, разбивающий <math>C{i}</math> на два равных подграфа.

*<math>RI_{(C_{i},C_{j})} = \frac{|EC_{(C_{i},C_{j})}|}{(|EC_{C_{i}}|+|EC_{C_{j}}|)/2}</math> - относительная взаимная связность пары кластеров <math>C_{i}, C{j}</math>

*<math>S_{EC_{(C_{i},C_{j})}}</math> - абсолютное взаимное сходство пары кластеров <math>C_{i}, C{j}</math>. Подсчитывается как среднее сходство между соединенными вершинами, принадлежащими <math>C{i}</math> и <math>C{j}</math> соответственно. Соединения обусловлены разбиением общего графа, полученного на первом этапе алгоритма.

*<math> RC_{(C_{i},C_{j})}= \frac{S_{EC_{(C_{i},C_{j})}}}{\frac{|C_{i}|}{|C_{i}+C_{j}|}*S_{EC_{(C_{i})}}+\frac{|C_{i}|}{|C_{i}+C_{j}|}*S_{EC_{(C_{j})}}}</math> - относительное взаимное сходство пары кластеров <math>C_{i}, C{j}</math>. Определяется как абсолютное сходство между этой парой кластеров, нормализованное с учетом их внутреннего сходства<ref>http://studopedia.ru/7_41934_algoritm-dinamicheskoy-ierarhicheskoy-klasterizatsii-CHAMELEON.html</ref>.

'''Первый этап'''

На первом этапе, согласно графо-ориентированному подходу, происходит построение графа <math>G = (V, E)</math> на матрице сходства объектов по принципу k ближайших соседей. Две вершины такого графа соединяет ребро, если объект, соответствующий любой из этих вершин попадает в число k наиболее близких объектов для объекта, соответствующего другой вершине из данной пары.
[[Файл:Снимок chameleon 2.png|2000px|thumb|Рисунок 2. Объекты в пространстве - слева, граф по принципу 1-го ближайшего соседа - по центру, граф по принципу 3-х ближайших соседей - справа ]]

'''Второй этап'''

Алгоритм разделяет полученный граф на множество сравнительно малых подграфов <math>K= \{K_{i}\}</math>. Разделение происходит последовательно. На каждом шаге выбирается подграф, содержащий наибольшее число вершин. Этот граф разделяется на два подграфа так, что разделитель ребер графа минимален и каждый из получаемых подграфов содержит не менее 25 % вершин исходного графа. Процесс разделения останавливается, когда наибольший подграф содержит меньше некоторого заданного числа вершин. Обычно величина этого параметра задается равной значению от 1 до 5 % от числа объектов. Полученное множество связных графов считается множеством начальных кластеров, на котором требуется провести последовательное иерархическое объединение.

'''Третий этап'''

Третий этап заключается в итеративном преобразовании множества подграфов <math>K= \{K_{i}\}</math> в множество кластеров <math>C = \{C_{i}\}</math>. Алгоритм осуществляет агломеративную иерархическую кластеризацию на основании показателей <math>EC_{(C_{i},C_{j})}</math>, <math>S_{EC_{(C_{i},C_{j})}}</math>, <math>RI_{(C_{i},C_{j})} </math>, <math> RC_{(C_{i},C_{j})}</math>. Существует две стратегии анализа показателей сходства. Первая подразумевает наличие некоторых пороговых значений <math>T_{RI}</math> и <math>T_{RC}</math>. В соответствии с этой стратегией, алгоритм для каждого кластера <math>C_{i}</math> проверяет, отвечают ли смежные (наиболее близкие) ему кластеры условиям:

*<math>RI_{(C_{i},C_{j})} \geqslant T_{RI}</math>

*<math>RC_{(C_{i},C_{j})} \geqslant T_{RC}</math>

Если более одного смежного кластера отвечает этим условиям, то алгоритм выбирает для объединения наиболее связный кластер (граф), то есть такой кластер <math>C_{j}</math>, с которым у кластера <math>C_{i}</math> получается наибольшая абсолютная взаимная связность. По завершению прохода по всем кластерам, созданные таким образом пары объединяются. Параметры <math>T_{RI}</math> и <math>T_{RC}</math> могут использоваться для изменения характеристик получаемых кластеров.

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

<math>RI_{(C_{i},C_{j})}*RC_{(C_{i},C_{j})}^\alpha</math>,

где <math>\alpha</math> выбирается пользователем. Если <math>\alpha > 1 </math>, то алгоритм придает большее значение относительному взаимному сходству, а если <math>\alpha < 1 </math>, то большее значение имеет относительная взаимная связность.

''Вычисляемые данные'':

<math>U = (u_1, u_2, ..., u_n)</math> - n-мерный вектор, где <math>u_i \in N_{[C]}</math> - порядковый номер кластера, к которому принадлежит вершина i исходного множества V.

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

Алгоритм имеет три вычислительных ядра, по одному на каждый этап.

На первом этапе вычислительным ядром является процесс нахождения <math>k</math> ближайших соседей для каждой вершины, который заключается в анализе матрицы расстояний.

На втором этапе вычислительным ядром является процесс поиска подходящего разбиения очередного подграфа на два графа с минимизацией разделителя ребер графа.

На третьем этапе вычислительным ядром является расчет величин <math>EC_{(C_{i},C_{j})}</math>, <math>S_{EC_{(C_{i},C_{j})}}</math>, <math>RI_{(C_{i},C_{j})} </math>, <math> RC_{(C_{i},C_{j})}</math> для каждой пары смежных кластеров.

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

Как уже рассказывалось ранее, алгоритм включает в себя три основных этапа, каждый из которых, по сути, является отдельным алгоритмом. Этапы выполняются последовательно относительно друг друга.

Макрооперация на первом этапе - процедура нахождения <math>k</math> ближайших соседей, на втором - процедура разбиения наибольшего подграфа на два графа, на третьем - процедура вычисления показателей сходства, на основе которых принимается решение о слиянии подграфов в кластер.

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

'''Первый этап'''
<source lang="cpp">
int n; //количество вершин
int k; //количество соседей
int A[n][n] //матрица расстояний
int D[k] //массив вершин-соседей
int E[n][n] //матрица ребер графа <math>G_{2} = (K, E_{2})</math>
for i=1 to n-1 do
{
for j=i+1 to n do
{
//заполняем массив вершин-соседей вставляя новые вершины, если они ближе, чем самая далекая из массива.
}
for j=0 to k do
{
//для каждой вершины соседа заполняем соответствующую ячейку из матрицы E[n][n] единицей
}

}
</source>

'''Второй этап'''

1. Все связные подграфы в отсортированном порядке помещаются в список;
2. Берем наибольший элемент списка, вычисляем количество его вершин. Если число вершин > l, то идем в пункт 3. Иначе в пункт 5;
3. Разбиваем подграф на два подграфа таким образом, чтобы разделитель ребер графа был минимален и каждый из получаемых подграфов содержал не менее 25 % вершин исходного графа;
4. Добавляем полученные элементы в список подграфов таким образом, чтобы список оставался отсортированным. Идем в пункт 2;
5. Нашли искомое множество подграфов math>K = \{K_{i}\}</math>;
6. Создаем и заполняем матрицу матрицу расстояний для графа <math>G_{2} = (K, E_{2})</math>. Получаем искомый набор рёбер <math>E_{2}</math>.

'''Третий этап'''

1. Заводим два массива: а) массив кластеров C, полученных на предыдущем этапе, б) массив объединений кластеров F, которые мы будем получать на этом этапе;
2. Берем следующий кластер <math>C_{i}</math> (на первом шаге - первый). Если все кластеры просмотрены, идем в пункт 6;
3. Берем следующий кластер <math>C_{j}, i<>j</math>. Если все кластеры просмотрены, то идем в пункт 2;
4. Проверяем смежность <math>C_{i}</math> и <math>C_{j}</math>. Если не смежны, то возвращаемся в пункт 3. Если смежны, идем в пункт 5;
5. Рассчитываем показатели <math>RI_{(C_{i},C_{j})}</math> и <math> RC_{(C_{i},C_{j})}</math>. Проверяем, удовлетворяют ли найденные значения условиям:
*<math>RI_{(C_{i},C_{j})} \geqslant T_{RI}</math>
*<math>RC_{(C_{i},C_{j})} \geqslant T_{RC}</math>
Если нет, то идем в пункт 3. Иначе если смежность пары кластеров выше, чем у предыдущих найденных, то <math>F_{i}=j</math>. Идем в пункт 3;
6. Если в списке F есть хотя бы одна пара кластеров для слияния, то выполняем слияние, обновляем массив кластеров и массив объединений кластеров. Идем в пункт 2.

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

1) Для построения графа на основе метода k ближайших соседей для n вершин требуется <math>O(n log(n))</math> операций <ref>J.H. Friedman, J.L. Bentley, and R.A. Finkel. An algorithm for ﬁnding best matches in logarithmic expected time. ACM Transactions on Mathematical Software, 3:209–226, 1977.</ref>; для наборов данных большой размерности эта величина составляет <math>O(n^2)</math> операций <ref>S. Berchtold, C. Bohm, D. Keim, and H.-P. Kriegel. Cost model for nearest neighbor search in high dimensional data space. In Proc. of Symposium on Principles of Database Systems, Tucson, Arizona, 1997.</ref>;

2) Для выделения множества сравнительно малых связных подграфов требуется <math>nm</math> операций, где <math>m</math> - количество подграфов, полученных на втором этапе алгоритма;

3) Формирование набора кластеров, на основе множества подграфов, полученных на предыдущем этапе, требует <math>m^2log(m)</math> операций.

Итого, для n вершин получаем последовательную сложность <math>O(n log(n)+nm+m^2log(m))</math>.

== Информационный граф ==
[[File:СК.png]]

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

Первый этап работы алгоритма можно распределить между <math>n</math> процессами. На вход каждому процессу подается своя вершина, далее происходит процедура поиска <math>k</math> ближайших соседей. Параллельная сложность составляет <math>O(n)</math>.

Второй и третий этапы можно распараллелить частично.

Второй этап распараллеливается путем подачи на вход свободному процессу очередного подграфа для разделения. Число итераций оценивается в <math>O(n log(n))</math>.

Третий этап делится на расчет показателей схожести и соединение подграфов в кластеры. Процесс расчета показателей можно распараллелить, подавая каждому процессу на вход пару подграфов. Сложность этого процесса оценивается как <math>m log(m)</math>. Соединение подграфов в кластеры выполняется последовательно, сложность процесса составляет <math>m^2 log(m)</math>

Таким образом получаем общую параллельную сложность алгоритма: <math>O(n+ n log(n) + m^2 log (m) + m log(m))</math>

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

1. Симметрическая матрица <math>A</math> расстояний между элементами данных размера <math>n\times n</math> с нулями на главной диагонали (<math>a_{ii}= 0, i = 1, \ldots, N</math>).

2. <math>k</math> - количество ближайших соседей для вершин (рекомендуемое значение <math>k</math> от 5 до 20 в зависимости от количества анализируемых объектов).

3. <math>l</math> - наименьшее число вершин, которое может содержать наибольший подкластер на 2-м этапе . Величина этого параметра варьируется от 1 до 5 % от общего числа объектов.

'''Объём входных данных'''

<math>\frac{n (n - 1)}{2}</math> (в силу симметричности и нулевой главной диагонали достаточно хранить только над/поддиагональные элементы).

'''Выходные данные'''

Вектор из <math>n</math> чисел <math>u_{1}, u_{2}, \ldots, u_{N}</math>, где <math>u_{i}</math> - целое число, соответствующее кластеру <math>i</math>-го объекта.

'''Объём выходных данных'''

<math>n</math>

== Свойства алгоритма ==
Соотношение последовательной и параллельной сложности на первом этапе является ''линейным'' для больших наборов данных и логарифмическим для n вершин. На втором этапе сложно оценить это соотношение - оно сильно зависит от параметров <math>k</math> и <math>l</math>. На третьем этапе соотношение равно <math>O(1)</math>;

Оценка ''вычислительной мощности'' выглядит следующим образом:

<math>O(1)</math> для 1-го этапа;

<math>O(\frac{nm}{n^2+m})</math> для 2-го этапа;

<math>O(\frac{m^2log(m)}{m+n})</math> для 3-го этапа;

Алгоритм является ''недетерминированным''. Хотя 1-й этап детерминирован, на 2-ом этапе могут быть найдены различные разбиения на подграфы, что повлияет и на итоговый результат работы алгоритма.

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

см. позднее

== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Последовательная реализация алгоритма доступна по ссылке <ref>http://www.codeforge.com/article/192925</ref>.

CHAMELEON можно реализовать с использованием графовых библиотек METIS <ref>http://glaros.dtc.umn.edu/gkhome/metis/metis/overview
</ref>, hMETIS <ref>http://glaros.dtc.umn.edu/gkhome/metis/hmetis/overview</ref> и RANN <ref>https://cran.r-project.org/web/packages/RANN/index.html</ref>.

Существует исследование, связанное с реализацией CHAMELEON посредством технологии OpenMP, с которым можно ознакомиться здесь <ref>http://research.ijcaonline.org/volume79/number8/pxc3891600.pdf</ref>.

Параллельных реализаций алгоритма CHAMELEON не найдено.

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

Участник:ЕкатеринаКозырева/Алгоритм динамической иерархической кластеризации CHAMELEON

2016-10-31T19:48:13Z

ЕкатеринаКозырева: /* Свойства алгоритма */

{{algorithm
| name = Алгоритм динамической иерархической кластеризации CHAMELEON
| serial_complexity = <math>O(nm + n log n + m^2 log m)</math>
| input_data = <math>\frac{n (n - 1)}{2}</math>
| output_data = <math>n</math>
| pf_height = <math>O(n+ n log(n) + m^2 log (m) + m log(m))</math>
| pf_width = <math>O(n)</math>
}}

Автор описания [[Участник:ЕкатеринаКозырева|Е.А.Козырева]]
= Свойства и структура алгоритмов =

== Общее описание алгоритма ==
Алгоритм CHAMELEON был предложен в 1999 году тремя учеными из университета Миннесоты – George Karypis, Eui-Hong (Sam) Han и Vipin Kumar<ref>George Karypis, Eui-Hong (Sam) Han и Vipin Kumar, «Chameleon: Hierarchical Clustering Using Dynamic Modeling», 1999.</ref>.

Предназначен для решения задач кластеризации. Кластеризация (или кластерный анализ) — это задача разбиения множества объектов на группы, называемые кластерами. Внутри каждой группы должны оказаться «похожие» объекты, а объекты разных группы должны быть как можно более отличны.

CHAMELEON - это агломеративный иерархический алгоритм кластеризации, ключевой особенностью которого является то, что он учитывает и взаимную связность, и сходство при определении наиболее похожей пары подкластеров, основываясь на динамической модели. Это означает, что в процессе кластеризации два кластера объединяются, только если их относительная взаимная связность и относительное взаимное сходство являются высокими по отношению к внутренней взаимосвязанности кластеров и близости элементов внутри кластеров. Кроме того, CHAMELEON использует подход для моделирования степени взаимосвязанности и близости между каждой парой кластеров, который учитывает внутренние характеристики самих кластеров. Таким образом, он может автоматически адаптироваться к внутренним характеристикам объединяемых кластеров.

CHAMELEON находит кластеры в наборе данных с помощью трехфазного алгоритма. На первой фазе происходит построение графа, путём добавления рёбер по принципу k ближайших соседей. На второй фазе CHAMELEON группирует полученные элементы в множество относительно небольших подграфов. Во время третьей фазы применяется агломеративный иерархический алгоритм кластеризации, с помощью которого находятся естесственные кластеры путем многократного объединения подграфов, полученных на прошлом этапе.

[[File:Chameleon.png|1000px|thumb|center|Рисунок 1. Общая структура алгоритма CHAMELEON]]

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

''Исходные данные'':

* Множество из n точек <math>V= {v_{ij}}</math> в метрическом пространстве, которое задано симметрической матрицей расстояний <math>A</math> размера <math>n\times n</math>.
* <math>k</math> - количество ближайших соседей для вершин, <math>k \in N, k \leq n</math>.
* <math>l</math> - наименьшее число вершин, которое может содержать наибольший подграф на 2-м этапе, <math>l \in N, l \leq n</math>.

''Обозначения'':

* <math>G = (V, E)</math> - граф, полученный путём соединения каждой точки с её <math>k</math> ближайшими соседями.

* <math>K= \{K_{i}\}</math> - разбиение множества <math>V</math> на набор попарно непересекающихся связных подмножеств, полученное в результате выполнения второй фазы алгоритма.

* <math>G_{2} = (K, E_{2})</math> - взвешенный граф, вершинами которого являются получившиеся подграфы, а ребрами - количество ребер исходного графа, соединяющих соответствующие подграфы.

* <math>C = \{C_{i}\}</math> - итоговое разбиение множества вершин графа <math>G_{2}</math> на набор кластеров.

''Вспомогательные понятия''

*<math>EC_{(C_{i},C_{j})}</math> - абсолютная взаимная связность пары кластеров <math>C_{i}, C{j}</math>. Определяется как сумма весов ребер, соединяющих вершины, принадлежащие <math>C{i}</math> c вершинами из <math>C{j}</math>. Внутренняя связность <math>EC_{(C_{i},C_{i})}</math> вычисляется как сумма ребер, входящих в разделитель, разбивающий <math>C{i}</math> на два равных подграфа.

*<math>RI_{(C_{i},C_{j})} = \frac{|EC_{(C_{i},C_{j})}|}{(|EC_{C_{i}}|+|EC_{C_{j}}|)/2}</math> - относительная взаимная связность пары кластеров <math>C_{i}, C{j}</math>

*<math>S_{EC_{(C_{i},C_{j})}}</math> - абсолютное взаимное сходство пары кластеров <math>C_{i}, C{j}</math>. Подсчитывается как среднее сходство между соединенными вершинами, принадлежащими <math>C{i}</math> и <math>C{j}</math> соответственно. Соединения обусловлены разбиением общего графа, полученного на первом этапе алгоритма.

*<math> RC_{(C_{i},C_{j})}= \frac{S_{EC_{(C_{i},C_{j})}}}{\frac{|C_{i}|}{|C_{i}+C_{j}|}*S_{EC_{(C_{i})}}+\frac{|C_{i}|}{|C_{i}+C_{j}|}*S_{EC_{(C_{j})}}}</math> - относительное взаимное сходство пары кластеров <math>C_{i}, C{j}</math>. Определяется как абсолютное сходство между этой парой кластеров, нормализованное с учетом их внутреннего сходства<ref>http://studopedia.ru/7_41934_algoritm-dinamicheskoy-ierarhicheskoy-klasterizatsii-CHAMELEON.html</ref>.

'''Первый этап'''

На первом этапе, согласно графо-ориентированному подходу, происходит построение графа <math>G = (V, E)</math> на матрице сходства объектов по принципу k ближайших соседей. Две вершины такого графа соединяет ребро, если объект, соответствующий любой из этих вершин попадает в число k наиболее близких объектов для объекта, соответствующего другой вершине из данной пары.
[[Файл:Снимок chameleon 2.png|2000px|thumb|Рисунок 2. Объекты в пространстве - слева, граф по принципу 1-го ближайшего соседа - по центру, граф по принципу 3-х ближайших соседей - справа ]]

'''Второй этап'''

Алгоритм разделяет полученный граф на множество сравнительно малых подграфов <math>K= \{K_{i}\}</math>. Разделение происходит последовательно. На каждом шаге выбирается подграф, содержащий наибольшее число вершин. Этот граф разделяется на два подграфа так, что разделитель ребер графа минимален и каждый из получаемых подграфов содержит не менее 25 % вершин исходного графа. Процесс разделения останавливается, когда наибольший подграф содержит меньше некоторого заданного числа вершин. Обычно величина этого параметра задается равной значению от 1 до 5 % от числа объектов. Полученное множество связных графов считается множеством начальных кластеров, на котором требуется провести последовательное иерархическое объединение.

'''Третий этап'''

Третий этап заключается в итеративном преобразовании множества подграфов <math>K= \{K_{i}\}</math> в множество кластеров <math>C = \{C_{i}\}</math>. Алгоритм осуществляет агломеративную иерархическую кластеризацию на основании показателей <math>EC_{(C_{i},C_{j})}</math>, <math>S_{EC_{(C_{i},C_{j})}}</math>, <math>RI_{(C_{i},C_{j})} </math>, <math> RC_{(C_{i},C_{j})}</math>. Существует две стратегии анализа показателей сходства. Первая подразумевает наличие некоторых пороговых значений <math>T_{RI}</math> и <math>T_{RC}</math>. В соответствии с этой стратегией, алгоритм для каждого кластера <math>C_{i}</math> проверяет, отвечают ли смежные (наиболее близкие) ему кластеры условиям:

*<math>RI_{(C_{i},C_{j})} \geqslant T_{RI}</math>

*<math>RC_{(C_{i},C_{j})} \geqslant T_{RC}</math>

Если более одного смежного кластера отвечает этим условиям, то алгоритм выбирает для объединения наиболее связный кластер (граф), то есть такой кластер <math>C_{j}</math>, с которым у кластера <math>C_{i}</math> получается наибольшая абсолютная взаимная связность. По завершению прохода по всем кластерам, созданные таким образом пары объединяются. Параметры <math>T_{RI}</math> и <math>T_{RC}</math> могут использоваться для изменения характеристик получаемых кластеров.

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

<math>RI_{(C_{i},C_{j})}*RC_{(C_{i},C_{j})}^\alpha</math>,

где <math>\alpha</math> выбирается пользователем. Если <math>\alpha > 1 </math>, то алгоритм придает большее значение относительному взаимному сходству, а если <math>\alpha < 1 </math>, то большее значение имеет относительная взаимная связность.

''Вычисляемые данные'':

<math>U = (u_1, u_2, ..., u_n)</math> - n-мерный вектор, где <math>u_i \in N_{[C]}</math> - порядковый номер кластера, к которому принадлежит вершина i исходного множества V.

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

Алгоритм имеет три вычислительных ядра, по одному на каждый этап.

На первом этапе вычислительным ядром является процесс нахождения <math>k</math> ближайших соседей для каждой вершины, который заключается в анализе матрицы расстояний.

На втором этапе вычислительным ядром является процесс поиска подходящего разбиения очередного подграфа на два графа с минимизацией разделителя ребер графа.

На третьем этапе вычислительным ядром является расчет величин <math>EC_{(C_{i},C_{j})}</math>, <math>S_{EC_{(C_{i},C_{j})}}</math>, <math>RI_{(C_{i},C_{j})} </math>, <math> RC_{(C_{i},C_{j})}</math> для каждой пары смежных кластеров.

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

Как уже рассказывалось ранее, алгоритм включает в себя три основных этапа, каждый из которых, по сути, является отдельным алгоритмом. Этапы выполняются последовательно относительно друг друга.

Макрооперация на первом этапе - процедура нахождения <math>k</math> ближайших соседей, на втором - процедура разбиения наибольшего подграфа на два графа, на третьем - процедура вычисления показателей сходства, на основе которых принимается решение о слиянии подграфов в кластер.

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

'''Первый этап'''
<source lang="cpp">
int n; //количество вершин
int k; //количество соседей
int A[n][n] //матрица расстояний
int D[k] //массив вершин-соседей
int E[n][n] //матрица ребер графа <math>G_{2} = (K, E_{2})</math>
for i=1 to n-1 do
{
for j=i+1 to n do
{
//заполняем массив вершин-соседей вставляя новые вершины, если они ближе, чем самая далекая из массива.
}
for j=0 to k do
{
//для каждой вершины соседа заполняем соответствующую ячейку из матрицы E[n][n] единицей
}

}
</source>

'''Второй этап'''

1. Все связные подграфы в отсортированном порядке помещаются в список;
2. Берем наибольший элемент списка, вычисляем количество его вершин. Если число вершин > l, то идем в пункт 3. Иначе в пункт 5;
3. Разбиваем подграф на два подграфа таким образом, чтобы разделитель ребер графа был минимален и каждый из получаемых подграфов содержал не менее 25 % вершин исходного графа;
4. Добавляем полученные элементы в список подграфов таким образом, чтобы список оставался отсортированным. Идем в пункт 2;
5. Нашли искомое множество подграфов math>K = \{K_{i}\}</math>;
6. Создаем и заполняем матрицу матрицу расстояний для графа <math>G_{2} = (K, E_{2})</math>. Получаем искомый набор рёбер <math>E_{2}</math>.

'''Третий этап'''

1. Заводим два массива: а) массив кластеров C, полученных на предыдущем этапе, б) массив объединений кластеров F, которые мы будем получать на этом этапе;
2. Берем следующий кластер <math>C_{i}</math> (на первом шаге - первый). Если все кластеры просмотрены, идем в пункт 6;
3. Берем следующий кластер <math>C_{j}, i<>j</math>. Если все кластеры просмотрены, то идем в пункт 2;
4. Проверяем смежность <math>C_{i}</math> и <math>C_{j}</math>. Если не смежны, то возвращаемся в пункт 3. Если смежны, идем в пункт 5;
5. Рассчитываем показатели <math>RI_{(C_{i},C_{j})}</math> и <math> RC_{(C_{i},C_{j})}</math>. Проверяем, удовлетворяют ли найденные значения условиям:
*<math>RI_{(C_{i},C_{j})} \geqslant T_{RI}</math>
*<math>RC_{(C_{i},C_{j})} \geqslant T_{RC}</math>
Если нет, то идем в пункт 3. Иначе если смежность пары кластеров выше, чем у предыдущих найденных, то <math>F_{i}=j</math>. Идем в пункт 3;
6. Если в списке F есть хотя бы одна пара кластеров для слияния, то выполняем слияние, обновляем массив кластеров и массив объединений кластеров. Идем в пункт 2.

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

1) Для построения графа на основе метода k ближайших соседей для n вершин требуется <math>O(n log(n))</math> операций <ref>J.H. Friedman, J.L. Bentley, and R.A. Finkel. An algorithm for ﬁnding best matches in logarithmic expected time. ACM Transactions on Mathematical Software, 3:209–226, 1977.</ref>; для наборов данных большой размерности эта величина составляет <math>O(n^2)</math> операций <ref>S. Berchtold, C. Bohm, D. Keim, and H.-P. Kriegel. Cost model for nearest neighbor search in high dimensional data space. In Proc. of Symposium on Principles of Database Systems, Tucson, Arizona, 1997.</ref>;

2) Для выделения множества сравнительно малых связных подграфов требуется <math>nm</math> операций, где <math>m</math> - количество подграфов, полученных на втором этапе алгоритма;

3) Формирование набора кластеров, на основе множества подграфов, полученных на предыдущем этапе, требует <math>m^2log(m)</math> операций.

Итого, для n вершин получаем последовательную сложность <math>O(n log(n)+nm+m^2log(m))</math>.

== Информационный граф ==
[[File:СК.png]]

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

Первый этап работы алгоритма можно распределить между <math>n</math> процессами. На вход каждому процессу подается своя вершина, далее происходит процедура поиска <math>k</math> ближайших соседей. Параллельная сложность составляет <math>O(n)</math>.

Второй и третий этапы можно распараллелить частично.

Второй этап распараллеливается путем подачи на вход свободному процессу очередного подграфа для разделения. Число итераций оценивается в <math>O(n log(n))</math>.

Третий этап делится на расчет показателей схожести и соединение подграфов в кластеры. Процесс расчета показателей можно распараллелить, подавая каждому процессу на вход пару подграфов. Сложность этого процесса оценивается как <math>m log(m)</math>. Соединение подграфов в кластеры выполняется последовательно, сложность процесса составляет <math>m^2 log(m)</math>

Таким образом получаем общую параллельную сложность алгоритма: <math>O(n+ n log(n) + m^2 log (m) + m log(m))</math>

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

1. Симметрическая матрица <math>A</math> расстояний между элементами данных размера <math>n\times n</math> с нулями на главной диагонали (<math>a_{ii}= 0, i = 1, \ldots, N</math>).

2. <math>k</math> - количество ближайших соседей для вершин (рекомендуемое значение <math>k</math> от 5 до 20 в зависимости от количества анализируемых объектов).

3. <math>l</math> - наименьшее число вершин, которое может содержать наибольший подкластер на 2-м этапе . Величина этого параметра варьируется от 1 до 5 % от общего числа объектов.

'''Объём входных данных'''

<math>\frac{n (n - 1)}{2}</math> (в силу симметричности и нулевой главной диагонали достаточно хранить только над/поддиагональные элементы).

'''Выходные данные'''

Вектор из <math>n</math> чисел <math>u_{1}, u_{2}, \ldots, u_{N}</math>, где <math>u_{i}</math> - целое число, соответствующее кластеру <math>i</math>-го объекта.

'''Объём выходных данных'''

<math>n</math>

== Свойства алгоритма ==
Соотношение последовательной и параллельной сложности на первом этапе является ''линейным'' для больших наборов данных и логарифмическим для n вершин. На втором этапе сложно оценить это соотношение - оно сильно зависит от параметров <math>k</math> и <math>l</math>. На третьем этапе соотношение равно <math>O(1)</math>;

Оценка ''вычислительной мощности'' выглядит следующим образом:

<math>O(1)</math> для 1-го этапа;

<math>O(\frac{nm}{n^2+m})</math> для 2-го этапа;

<math>O(\frac{m^2log(m)}{m+n})</math> для 3-го этапа;

Алгоритм является ''недетерминированным''. Хотя 1-й этап детерминирован, на 2-ом этапе могут быть найдены различные разбиения на подграфы, что повлияет и на итоговый результат работы алгоритма.

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

см. позднее

== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Последовательная реализация алгоритма доступна по ссылке <ref>http://www.codeforge.com/article/192925</ref>.

CHAMELEON можно реализовать с использованием графовых библиотек METIS <ref>http://glaros.dtc.umn.edu/gkhome/metis/metis/overview
</ref>, hMETIS <ref>http://glaros.dtc.umn.edu/gkhome/metis/hmetis/overview</ref> и RANN <ref>https://cran.r-project.org/web/packages/RANN/index.html</ref>.

Существует исследование, связанное с реализацией CHAMELEON посредством технологии OpenMP, с которым можно ознакомиться здесь <ref>http://research.ijcaonline.org/volume79/number8/pxc3891600.pdf</ref>.

Параллельных реализаций алгоритма CHAMELEON не найдено.

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

Участник:ЕкатеринаКозырева/Алгоритм динамической иерархической кластеризации CHAMELEON

2016-10-31T19:47:00Z

ЕкатеринаКозырева: /* Свойства алгоритма */

{{algorithm
| name = Алгоритм динамической иерархической кластеризации CHAMELEON
| serial_complexity = <math>O(nm + n log n + m^2 log m)</math>
| input_data = <math>\frac{n (n - 1)}{2}</math>
| output_data = <math>n</math>
| pf_height = <math>O(n+ n log(n) + m^2 log (m) + m log(m))</math>
| pf_width = <math>O(n)</math>
}}

Автор описания [[Участник:ЕкатеринаКозырева|Е.А.Козырева]]
= Свойства и структура алгоритмов =

== Общее описание алгоритма ==
Алгоритм CHAMELEON был предложен в 1999 году тремя учеными из университета Миннесоты – George Karypis, Eui-Hong (Sam) Han и Vipin Kumar<ref>George Karypis, Eui-Hong (Sam) Han и Vipin Kumar, «Chameleon: Hierarchical Clustering Using Dynamic Modeling», 1999.</ref>.

Предназначен для решения задач кластеризации. Кластеризация (или кластерный анализ) — это задача разбиения множества объектов на группы, называемые кластерами. Внутри каждой группы должны оказаться «похожие» объекты, а объекты разных группы должны быть как можно более отличны.

CHAMELEON - это агломеративный иерархический алгоритм кластеризации, ключевой особенностью которого является то, что он учитывает и взаимную связность, и сходство при определении наиболее похожей пары подкластеров, основываясь на динамической модели. Это означает, что в процессе кластеризации два кластера объединяются, только если их относительная взаимная связность и относительное взаимное сходство являются высокими по отношению к внутренней взаимосвязанности кластеров и близости элементов внутри кластеров. Кроме того, CHAMELEON использует подход для моделирования степени взаимосвязанности и близости между каждой парой кластеров, который учитывает внутренние характеристики самих кластеров. Таким образом, он может автоматически адаптироваться к внутренним характеристикам объединяемых кластеров.

CHAMELEON находит кластеры в наборе данных с помощью трехфазного алгоритма. На первой фазе происходит построение графа, путём добавления рёбер по принципу k ближайших соседей. На второй фазе CHAMELEON группирует полученные элементы в множество относительно небольших подграфов. Во время третьей фазы применяется агломеративный иерархический алгоритм кластеризации, с помощью которого находятся естесственные кластеры путем многократного объединения подграфов, полученных на прошлом этапе.

[[File:Chameleon.png|1000px|thumb|center|Рисунок 1. Общая структура алгоритма CHAMELEON]]

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

''Исходные данные'':

* Множество из n точек <math>V= {v_{ij}}</math> в метрическом пространстве, которое задано симметрической матрицей расстояний <math>A</math> размера <math>n\times n</math>.
* <math>k</math> - количество ближайших соседей для вершин, <math>k \in N, k \leq n</math>.
* <math>l</math> - наименьшее число вершин, которое может содержать наибольший подграф на 2-м этапе, <math>l \in N, l \leq n</math>.

''Обозначения'':

* <math>G = (V, E)</math> - граф, полученный путём соединения каждой точки с её <math>k</math> ближайшими соседями.

* <math>K= \{K_{i}\}</math> - разбиение множества <math>V</math> на набор попарно непересекающихся связных подмножеств, полученное в результате выполнения второй фазы алгоритма.

* <math>G_{2} = (K, E_{2})</math> - взвешенный граф, вершинами которого являются получившиеся подграфы, а ребрами - количество ребер исходного графа, соединяющих соответствующие подграфы.

* <math>C = \{C_{i}\}</math> - итоговое разбиение множества вершин графа <math>G_{2}</math> на набор кластеров.

''Вспомогательные понятия''

*<math>EC_{(C_{i},C_{j})}</math> - абсолютная взаимная связность пары кластеров <math>C_{i}, C{j}</math>. Определяется как сумма весов ребер, соединяющих вершины, принадлежащие <math>C{i}</math> c вершинами из <math>C{j}</math>. Внутренняя связность <math>EC_{(C_{i},C_{i})}</math> вычисляется как сумма ребер, входящих в разделитель, разбивающий <math>C{i}</math> на два равных подграфа.

*<math>RI_{(C_{i},C_{j})} = \frac{|EC_{(C_{i},C_{j})}|}{(|EC_{C_{i}}|+|EC_{C_{j}}|)/2}</math> - относительная взаимная связность пары кластеров <math>C_{i}, C{j}</math>

*<math>S_{EC_{(C_{i},C_{j})}}</math> - абсолютное взаимное сходство пары кластеров <math>C_{i}, C{j}</math>. Подсчитывается как среднее сходство между соединенными вершинами, принадлежащими <math>C{i}</math> и <math>C{j}</math> соответственно. Соединения обусловлены разбиением общего графа, полученного на первом этапе алгоритма.

*<math> RC_{(C_{i},C_{j})}= \frac{S_{EC_{(C_{i},C_{j})}}}{\frac{|C_{i}|}{|C_{i}+C_{j}|}*S_{EC_{(C_{i})}}+\frac{|C_{i}|}{|C_{i}+C_{j}|}*S_{EC_{(C_{j})}}}</math> - относительное взаимное сходство пары кластеров <math>C_{i}, C{j}</math>. Определяется как абсолютное сходство между этой парой кластеров, нормализованное с учетом их внутреннего сходства<ref>http://studopedia.ru/7_41934_algoritm-dinamicheskoy-ierarhicheskoy-klasterizatsii-CHAMELEON.html</ref>.

'''Первый этап'''

На первом этапе, согласно графо-ориентированному подходу, происходит построение графа <math>G = (V, E)</math> на матрице сходства объектов по принципу k ближайших соседей. Две вершины такого графа соединяет ребро, если объект, соответствующий любой из этих вершин попадает в число k наиболее близких объектов для объекта, соответствующего другой вершине из данной пары.
[[Файл:Снимок chameleon 2.png|2000px|thumb|Рисунок 2. Объекты в пространстве - слева, граф по принципу 1-го ближайшего соседа - по центру, граф по принципу 3-х ближайших соседей - справа ]]

'''Второй этап'''

Алгоритм разделяет полученный граф на множество сравнительно малых подграфов <math>K= \{K_{i}\}</math>. Разделение происходит последовательно. На каждом шаге выбирается подграф, содержащий наибольшее число вершин. Этот граф разделяется на два подграфа так, что разделитель ребер графа минимален и каждый из получаемых подграфов содержит не менее 25 % вершин исходного графа. Процесс разделения останавливается, когда наибольший подграф содержит меньше некоторого заданного числа вершин. Обычно величина этого параметра задается равной значению от 1 до 5 % от числа объектов. Полученное множество связных графов считается множеством начальных кластеров, на котором требуется провести последовательное иерархическое объединение.

'''Третий этап'''

Третий этап заключается в итеративном преобразовании множества подграфов <math>K= \{K_{i}\}</math> в множество кластеров <math>C = \{C_{i}\}</math>. Алгоритм осуществляет агломеративную иерархическую кластеризацию на основании показателей <math>EC_{(C_{i},C_{j})}</math>, <math>S_{EC_{(C_{i},C_{j})}}</math>, <math>RI_{(C_{i},C_{j})} </math>, <math> RC_{(C_{i},C_{j})}</math>. Существует две стратегии анализа показателей сходства. Первая подразумевает наличие некоторых пороговых значений <math>T_{RI}</math> и <math>T_{RC}</math>. В соответствии с этой стратегией, алгоритм для каждого кластера <math>C_{i}</math> проверяет, отвечают ли смежные (наиболее близкие) ему кластеры условиям:

*<math>RI_{(C_{i},C_{j})} \geqslant T_{RI}</math>

*<math>RC_{(C_{i},C_{j})} \geqslant T_{RC}</math>

Если более одного смежного кластера отвечает этим условиям, то алгоритм выбирает для объединения наиболее связный кластер (граф), то есть такой кластер <math>C_{j}</math>, с которым у кластера <math>C_{i}</math> получается наибольшая абсолютная взаимная связность. По завершению прохода по всем кластерам, созданные таким образом пары объединяются. Параметры <math>T_{RI}</math> и <math>T_{RC}</math> могут использоваться для изменения характеристик получаемых кластеров.

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

<math>RI_{(C_{i},C_{j})}*RC_{(C_{i},C_{j})}^\alpha</math>,

где <math>\alpha</math> выбирается пользователем. Если <math>\alpha > 1 </math>, то алгоритм придает большее значение относительному взаимному сходству, а если <math>\alpha < 1 </math>, то большее значение имеет относительная взаимная связность.

''Вычисляемые данные'':

<math>U = (u_1, u_2, ..., u_n)</math> - n-мерный вектор, где <math>u_i \in N_{[C]}</math> - порядковый номер кластера, к которому принадлежит вершина i исходного множества V.

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

Алгоритм имеет три вычислительных ядра, по одному на каждый этап.

На первом этапе вычислительным ядром является процесс нахождения <math>k</math> ближайших соседей для каждой вершины, который заключается в анализе матрицы расстояний.

На втором этапе вычислительным ядром является процесс поиска подходящего разбиения очередного подграфа на два графа с минимизацией разделителя ребер графа.

На третьем этапе вычислительным ядром является расчет величин <math>EC_{(C_{i},C_{j})}</math>, <math>S_{EC_{(C_{i},C_{j})}}</math>, <math>RI_{(C_{i},C_{j})} </math>, <math> RC_{(C_{i},C_{j})}</math> для каждой пары смежных кластеров.

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

Как уже рассказывалось ранее, алгоритм включает в себя три основных этапа, каждый из которых, по сути, является отдельным алгоритмом. Этапы выполняются последовательно относительно друг друга.

Макрооперация на первом этапе - процедура нахождения <math>k</math> ближайших соседей, на втором - процедура разбиения наибольшего подграфа на два графа, на третьем - процедура вычисления показателей сходства, на основе которых принимается решение о слиянии подграфов в кластер.

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

'''Первый этап'''
<source lang="cpp">
int n; //количество вершин
int k; //количество соседей
int A[n][n] //матрица расстояний
int D[k] //массив вершин-соседей
int E[n][n] //матрица ребер графа <math>G_{2} = (K, E_{2})</math>
for i=1 to n-1 do
{
for j=i+1 to n do
{
//заполняем массив вершин-соседей вставляя новые вершины, если они ближе, чем самая далекая из массива.
}
for j=0 to k do
{
//для каждой вершины соседа заполняем соответствующую ячейку из матрицы E[n][n] единицей
}

}
</source>

'''Второй этап'''

1. Все связные подграфы в отсортированном порядке помещаются в список;
2. Берем наибольший элемент списка, вычисляем количество его вершин. Если число вершин > l, то идем в пункт 3. Иначе в пункт 5;
3. Разбиваем подграф на два подграфа таким образом, чтобы разделитель ребер графа был минимален и каждый из получаемых подграфов содержал не менее 25 % вершин исходного графа;
4. Добавляем полученные элементы в список подграфов таким образом, чтобы список оставался отсортированным. Идем в пункт 2;
5. Нашли искомое множество подграфов math>K = \{K_{i}\}</math>;
6. Создаем и заполняем матрицу матрицу расстояний для графа <math>G_{2} = (K, E_{2})</math>. Получаем искомый набор рёбер <math>E_{2}</math>.

'''Третий этап'''

1. Заводим два массива: а) массив кластеров C, полученных на предыдущем этапе, б) массив объединений кластеров F, которые мы будем получать на этом этапе;
2. Берем следующий кластер <math>C_{i}</math> (на первом шаге - первый). Если все кластеры просмотрены, идем в пункт 6;
3. Берем следующий кластер <math>C_{j}, i<>j</math>. Если все кластеры просмотрены, то идем в пункт 2;
4. Проверяем смежность <math>C_{i}</math> и <math>C_{j}</math>. Если не смежны, то возвращаемся в пункт 3. Если смежны, идем в пункт 5;
5. Рассчитываем показатели <math>RI_{(C_{i},C_{j})}</math> и <math> RC_{(C_{i},C_{j})}</math>. Проверяем, удовлетворяют ли найденные значения условиям:
*<math>RI_{(C_{i},C_{j})} \geqslant T_{RI}</math>
*<math>RC_{(C_{i},C_{j})} \geqslant T_{RC}</math>
Если нет, то идем в пункт 3. Иначе если смежность пары кластеров выше, чем у предыдущих найденных, то <math>F_{i}=j</math>. Идем в пункт 3;
6. Если в списке F есть хотя бы одна пара кластеров для слияния, то выполняем слияние, обновляем массив кластеров и массив объединений кластеров. Идем в пункт 2.

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

1) Для построения графа на основе метода k ближайших соседей для n вершин требуется <math>O(n log(n))</math> операций <ref>J.H. Friedman, J.L. Bentley, and R.A. Finkel. An algorithm for ﬁnding best matches in logarithmic expected time. ACM Transactions on Mathematical Software, 3:209–226, 1977.</ref>; для наборов данных большой размерности эта величина составляет <math>O(n^2)</math> операций <ref>S. Berchtold, C. Bohm, D. Keim, and H.-P. Kriegel. Cost model for nearest neighbor search in high dimensional data space. In Proc. of Symposium on Principles of Database Systems, Tucson, Arizona, 1997.</ref>;

2) Для выделения множества сравнительно малых связных подграфов требуется <math>nm</math> операций, где <math>m</math> - количество подграфов, полученных на втором этапе алгоритма;

3) Формирование набора кластеров, на основе множества подграфов, полученных на предыдущем этапе, требует <math>m^2log(m)</math> операций.

Итого, для n вершин получаем последовательную сложность <math>O(n log(n)+nm+m^2log(m))</math>.

== Информационный граф ==
[[File:СК.png]]

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

Первый этап работы алгоритма можно распределить между <math>n</math> процессами. На вход каждому процессу подается своя вершина, далее происходит процедура поиска <math>k</math> ближайших соседей. Параллельная сложность составляет <math>O(n)</math>.

Второй и третий этапы можно распараллелить частично.

Второй этап распараллеливается путем подачи на вход свободному процессу очередного подграфа для разделения. Число итераций оценивается в <math>O(n log(n))</math>.

Третий этап делится на расчет показателей схожести и соединение подграфов в кластеры. Процесс расчета показателей можно распараллелить, подавая каждому процессу на вход пару подграфов. Сложность этого процесса оценивается как <math>m log(m)</math>. Соединение подграфов в кластеры выполняется последовательно, сложность процесса составляет <math>m^2 log(m)</math>

Таким образом получаем общую параллельную сложность алгоритма: <math>O(n+ n log(n) + m^2 log (m) + m log(m))</math>

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

1. Симметрическая матрица <math>A</math> расстояний между элементами данных размера <math>n\times n</math> с нулями на главной диагонали (<math>a_{ii}= 0, i = 1, \ldots, N</math>).

2. <math>k</math> - количество ближайших соседей для вершин (рекомендуемое значение <math>k</math> от 5 до 20 в зависимости от количества анализируемых объектов).

3. <math>l</math> - наименьшее число вершин, которое может содержать наибольший подкластер на 2-м этапе . Величина этого параметра варьируется от 1 до 5 % от общего числа объектов.

'''Объём входных данных'''

<math>\frac{n (n - 1)}{2}</math> (в силу симметричности и нулевой главной диагонали достаточно хранить только над/поддиагональные элементы).

'''Выходные данные'''

Вектор из <math>n</math> чисел <math>u_{1}, u_{2}, \ldots, u_{N}</math>, где <math>u_{i}</math> - целое число, соответствующее кластеру <math>i</math>-го объекта.

'''Объём выходных данных'''

<math>n</math>

== Свойства алгоритма ==
Соотношение последовательной и параллельной сложности на первом этапе является ''линейным'' для больших наборов данных и логарифмическим для n вершин. На втором этапе сложно оценить это соотношение - оно сильно зависит от параметров <math>k</math> и <math>l</math>. На третьем этапе соотношение равно <math>O(1)</math>

Оценка ''вычислительной мощности'' выглядит следующим образом:

<math>O(1)</math> :: для 1-го этапа

<math>O(\frac{nm}{n^2+m})</math> : для 2-го этапа

<math>O(\frac{m^2log(m)}{m+n})</math> для 3-го этапа

Алгоритм является ''недетерминированным''. Хотя 1-й этап детерминирован, на 2-ом этапе могут быть найдены различные разбиения на подграфы, что повлияет и на итоговый результат работы алгоритма.

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

см. позднее

== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Последовательная реализация алгоритма доступна по ссылке <ref>http://www.codeforge.com/article/192925</ref>.

CHAMELEON можно реализовать с использованием графовых библиотек METIS <ref>http://glaros.dtc.umn.edu/gkhome/metis/metis/overview
</ref>, hMETIS <ref>http://glaros.dtc.umn.edu/gkhome/metis/hmetis/overview</ref> и RANN <ref>https://cran.r-project.org/web/packages/RANN/index.html</ref>.

Существует исследование, связанное с реализацией CHAMELEON посредством технологии OpenMP, с которым можно ознакомиться здесь <ref>http://research.ijcaonline.org/volume79/number8/pxc3891600.pdf</ref>.

Параллельных реализаций алгоритма CHAMELEON не найдено.

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

Обсуждение участника:ЕкатеринаКозырева

2016-10-31T19:44:58Z

ЕкатеринаКозырева: /* Замечания к Участник:ЕкатеринаКозырева/Алгоритм_динамической_иерархической_кластеризации_CHAMELEON */

== Замечания к [[Участник:ЕкатеринаКозырева/Алгоритм_динамической_иерархической_кластеризации_CHAMELEON]] ==

1) отсутствует оценка высоты и ширины ЯПФ параллельного алгоритма во врезке в начале статьи

2) требуется какая-то подпись или ссылка на рисунок в п 1.1

3) подпись к рисунку 1.2 должны быть выполнена средствами разметки, а не на самой картинке

4) для оформления (псевдо) кода следует использовать тег <nowiki><source lang="..."></nowiki>

5) отсутствует оценка вычислительной мощности алгоритма в п 1.10

6) пункты 2.1 и 2.2 должны быть 2.4 и 2.7, согласно формату описания [[Структура_описания_свойств_алгоритмов]]

7) список литературы оформлен неправильно - см. как сделано в [[Разложение_Холецкого_(метод_квадратного_корня)]]

Участник:ЕкатеринаКозырева/Алгоритм динамической иерархической кластеризации CHAMELEON

2016-10-31T19:44:27Z

ЕкатеринаКозырева: /* Свойства алгоритма */

{{algorithm
| name = Алгоритм динамической иерархической кластеризации CHAMELEON
| serial_complexity = <math>O(nm + n log n + m^2 log m)</math>
| input_data = <math>\frac{n (n - 1)}{2}</math>
| output_data = <math>n</math>
| pf_height = <math>O(n+ n log(n) + m^2 log (m) + m log(m))</math>
| pf_width = <math>O(n)</math>
}}

Автор описания [[Участник:ЕкатеринаКозырева|Е.А.Козырева]]
= Свойства и структура алгоритмов =

== Общее описание алгоритма ==
Алгоритм CHAMELEON был предложен в 1999 году тремя учеными из университета Миннесоты – George Karypis, Eui-Hong (Sam) Han и Vipin Kumar<ref>George Karypis, Eui-Hong (Sam) Han и Vipin Kumar, «Chameleon: Hierarchical Clustering Using Dynamic Modeling», 1999.</ref>.

Предназначен для решения задач кластеризации. Кластеризация (или кластерный анализ) — это задача разбиения множества объектов на группы, называемые кластерами. Внутри каждой группы должны оказаться «похожие» объекты, а объекты разных группы должны быть как можно более отличны.

CHAMELEON - это агломеративный иерархический алгоритм кластеризации, ключевой особенностью которого является то, что он учитывает и взаимную связность, и сходство при определении наиболее похожей пары подкластеров, основываясь на динамической модели. Это означает, что в процессе кластеризации два кластера объединяются, только если их относительная взаимная связность и относительное взаимное сходство являются высокими по отношению к внутренней взаимосвязанности кластеров и близости элементов внутри кластеров. Кроме того, CHAMELEON использует подход для моделирования степени взаимосвязанности и близости между каждой парой кластеров, который учитывает внутренние характеристики самих кластеров. Таким образом, он может автоматически адаптироваться к внутренним характеристикам объединяемых кластеров.

CHAMELEON находит кластеры в наборе данных с помощью трехфазного алгоритма. На первой фазе происходит построение графа, путём добавления рёбер по принципу k ближайших соседей. На второй фазе CHAMELEON группирует полученные элементы в множество относительно небольших подграфов. Во время третьей фазы применяется агломеративный иерархический алгоритм кластеризации, с помощью которого находятся естесственные кластеры путем многократного объединения подграфов, полученных на прошлом этапе.

[[File:Chameleon.png|1000px|thumb|center|Рисунок 1. Общая структура алгоритма CHAMELEON]]

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

''Исходные данные'':

* Множество из n точек <math>V= {v_{ij}}</math> в метрическом пространстве, которое задано симметрической матрицей расстояний <math>A</math> размера <math>n\times n</math>.
* <math>k</math> - количество ближайших соседей для вершин, <math>k \in N, k \leq n</math>.
* <math>l</math> - наименьшее число вершин, которое может содержать наибольший подграф на 2-м этапе, <math>l \in N, l \leq n</math>.

''Обозначения'':

* <math>G = (V, E)</math> - граф, полученный путём соединения каждой точки с её <math>k</math> ближайшими соседями.

* <math>K= \{K_{i}\}</math> - разбиение множества <math>V</math> на набор попарно непересекающихся связных подмножеств, полученное в результате выполнения второй фазы алгоритма.

* <math>G_{2} = (K, E_{2})</math> - взвешенный граф, вершинами которого являются получившиеся подграфы, а ребрами - количество ребер исходного графа, соединяющих соответствующие подграфы.

* <math>C = \{C_{i}\}</math> - итоговое разбиение множества вершин графа <math>G_{2}</math> на набор кластеров.

''Вспомогательные понятия''

*<math>EC_{(C_{i},C_{j})}</math> - абсолютная взаимная связность пары кластеров <math>C_{i}, C{j}</math>. Определяется как сумма весов ребер, соединяющих вершины, принадлежащие <math>C{i}</math> c вершинами из <math>C{j}</math>. Внутренняя связность <math>EC_{(C_{i},C_{i})}</math> вычисляется как сумма ребер, входящих в разделитель, разбивающий <math>C{i}</math> на два равных подграфа.

*<math>RI_{(C_{i},C_{j})} = \frac{|EC_{(C_{i},C_{j})}|}{(|EC_{C_{i}}|+|EC_{C_{j}}|)/2}</math> - относительная взаимная связность пары кластеров <math>C_{i}, C{j}</math>

*<math>S_{EC_{(C_{i},C_{j})}}</math> - абсолютное взаимное сходство пары кластеров <math>C_{i}, C{j}</math>. Подсчитывается как среднее сходство между соединенными вершинами, принадлежащими <math>C{i}</math> и <math>C{j}</math> соответственно. Соединения обусловлены разбиением общего графа, полученного на первом этапе алгоритма.

*<math> RC_{(C_{i},C_{j})}= \frac{S_{EC_{(C_{i},C_{j})}}}{\frac{|C_{i}|}{|C_{i}+C_{j}|}*S_{EC_{(C_{i})}}+\frac{|C_{i}|}{|C_{i}+C_{j}|}*S_{EC_{(C_{j})}}}</math> - относительное взаимное сходство пары кластеров <math>C_{i}, C{j}</math>. Определяется как абсолютное сходство между этой парой кластеров, нормализованное с учетом их внутреннего сходства<ref>http://studopedia.ru/7_41934_algoritm-dinamicheskoy-ierarhicheskoy-klasterizatsii-CHAMELEON.html</ref>.

'''Первый этап'''

На первом этапе, согласно графо-ориентированному подходу, происходит построение графа <math>G = (V, E)</math> на матрице сходства объектов по принципу k ближайших соседей. Две вершины такого графа соединяет ребро, если объект, соответствующий любой из этих вершин попадает в число k наиболее близких объектов для объекта, соответствующего другой вершине из данной пары.
[[Файл:Снимок chameleon 2.png|2000px|thumb|Рисунок 2. Объекты в пространстве - слева, граф по принципу 1-го ближайшего соседа - по центру, граф по принципу 3-х ближайших соседей - справа ]]

'''Второй этап'''

Алгоритм разделяет полученный граф на множество сравнительно малых подграфов <math>K= \{K_{i}\}</math>. Разделение происходит последовательно. На каждом шаге выбирается подграф, содержащий наибольшее число вершин. Этот граф разделяется на два подграфа так, что разделитель ребер графа минимален и каждый из получаемых подграфов содержит не менее 25 % вершин исходного графа. Процесс разделения останавливается, когда наибольший подграф содержит меньше некоторого заданного числа вершин. Обычно величина этого параметра задается равной значению от 1 до 5 % от числа объектов. Полученное множество связных графов считается множеством начальных кластеров, на котором требуется провести последовательное иерархическое объединение.

'''Третий этап'''

Третий этап заключается в итеративном преобразовании множества подграфов <math>K= \{K_{i}\}</math> в множество кластеров <math>C = \{C_{i}\}</math>. Алгоритм осуществляет агломеративную иерархическую кластеризацию на основании показателей <math>EC_{(C_{i},C_{j})}</math>, <math>S_{EC_{(C_{i},C_{j})}}</math>, <math>RI_{(C_{i},C_{j})} </math>, <math> RC_{(C_{i},C_{j})}</math>. Существует две стратегии анализа показателей сходства. Первая подразумевает наличие некоторых пороговых значений <math>T_{RI}</math> и <math>T_{RC}</math>. В соответствии с этой стратегией, алгоритм для каждого кластера <math>C_{i}</math> проверяет, отвечают ли смежные (наиболее близкие) ему кластеры условиям:

*<math>RI_{(C_{i},C_{j})} \geqslant T_{RI}</math>

*<math>RC_{(C_{i},C_{j})} \geqslant T_{RC}</math>

Если более одного смежного кластера отвечает этим условиям, то алгоритм выбирает для объединения наиболее связный кластер (граф), то есть такой кластер <math>C_{j}</math>, с которым у кластера <math>C_{i}</math> получается наибольшая абсолютная взаимная связность. По завершению прохода по всем кластерам, созданные таким образом пары объединяются. Параметры <math>T_{RI}</math> и <math>T_{RC}</math> могут использоваться для изменения характеристик получаемых кластеров.

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

<math>RI_{(C_{i},C_{j})}*RC_{(C_{i},C_{j})}^\alpha</math>,

где <math>\alpha</math> выбирается пользователем. Если <math>\alpha > 1 </math>, то алгоритм придает большее значение относительному взаимному сходству, а если <math>\alpha < 1 </math>, то большее значение имеет относительная взаимная связность.

''Вычисляемые данные'':

<math>U = (u_1, u_2, ..., u_n)</math> - n-мерный вектор, где <math>u_i \in N_{[C]}</math> - порядковый номер кластера, к которому принадлежит вершина i исходного множества V.

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

Алгоритм имеет три вычислительных ядра, по одному на каждый этап.

На первом этапе вычислительным ядром является процесс нахождения <math>k</math> ближайших соседей для каждой вершины, который заключается в анализе матрицы расстояний.

На втором этапе вычислительным ядром является процесс поиска подходящего разбиения очередного подграфа на два графа с минимизацией разделителя ребер графа.

На третьем этапе вычислительным ядром является расчет величин <math>EC_{(C_{i},C_{j})}</math>, <math>S_{EC_{(C_{i},C_{j})}}</math>, <math>RI_{(C_{i},C_{j})} </math>, <math> RC_{(C_{i},C_{j})}</math> для каждой пары смежных кластеров.

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

Как уже рассказывалось ранее, алгоритм включает в себя три основных этапа, каждый из которых, по сути, является отдельным алгоритмом. Этапы выполняются последовательно относительно друг друга.

Макрооперация на первом этапе - процедура нахождения <math>k</math> ближайших соседей, на втором - процедура разбиения наибольшего подграфа на два графа, на третьем - процедура вычисления показателей сходства, на основе которых принимается решение о слиянии подграфов в кластер.

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

'''Первый этап'''
<source lang="cpp">
int n; //количество вершин
int k; //количество соседей
int A[n][n] //матрица расстояний
int D[k] //массив вершин-соседей
int E[n][n] //матрица ребер графа <math>G_{2} = (K, E_{2})</math>
for i=1 to n-1 do
{
for j=i+1 to n do
{
//заполняем массив вершин-соседей вставляя новые вершины, если они ближе, чем самая далекая из массива.
}
for j=0 to k do
{
//для каждой вершины соседа заполняем соответствующую ячейку из матрицы E[n][n] единицей
}

}
</source>

'''Второй этап'''

1. Все связные подграфы в отсортированном порядке помещаются в список;
2. Берем наибольший элемент списка, вычисляем количество его вершин. Если число вершин > l, то идем в пункт 3. Иначе в пункт 5;
3. Разбиваем подграф на два подграфа таким образом, чтобы разделитель ребер графа был минимален и каждый из получаемых подграфов содержал не менее 25 % вершин исходного графа;
4. Добавляем полученные элементы в список подграфов таким образом, чтобы список оставался отсортированным. Идем в пункт 2;
5. Нашли искомое множество подграфов math>K = \{K_{i}\}</math>;
6. Создаем и заполняем матрицу матрицу расстояний для графа <math>G_{2} = (K, E_{2})</math>. Получаем искомый набор рёбер <math>E_{2}</math>.

'''Третий этап'''

1. Заводим два массива: а) массив кластеров C, полученных на предыдущем этапе, б) массив объединений кластеров F, которые мы будем получать на этом этапе;
2. Берем следующий кластер <math>C_{i}</math> (на первом шаге - первый). Если все кластеры просмотрены, идем в пункт 6;
3. Берем следующий кластер <math>C_{j}, i<>j</math>. Если все кластеры просмотрены, то идем в пункт 2;
4. Проверяем смежность <math>C_{i}</math> и <math>C_{j}</math>. Если не смежны, то возвращаемся в пункт 3. Если смежны, идем в пункт 5;
5. Рассчитываем показатели <math>RI_{(C_{i},C_{j})}</math> и <math> RC_{(C_{i},C_{j})}</math>. Проверяем, удовлетворяют ли найденные значения условиям:
*<math>RI_{(C_{i},C_{j})} \geqslant T_{RI}</math>
*<math>RC_{(C_{i},C_{j})} \geqslant T_{RC}</math>
Если нет, то идем в пункт 3. Иначе если смежность пары кластеров выше, чем у предыдущих найденных, то <math>F_{i}=j</math>. Идем в пункт 3;
6. Если в списке F есть хотя бы одна пара кластеров для слияния, то выполняем слияние, обновляем массив кластеров и массив объединений кластеров. Идем в пункт 2.

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

1) Для построения графа на основе метода k ближайших соседей для n вершин требуется <math>O(n log(n))</math> операций <ref>J.H. Friedman, J.L. Bentley, and R.A. Finkel. An algorithm for ﬁnding best matches in logarithmic expected time. ACM Transactions on Mathematical Software, 3:209–226, 1977.</ref>; для наборов данных большой размерности эта величина составляет <math>O(n^2)</math> операций <ref>S. Berchtold, C. Bohm, D. Keim, and H.-P. Kriegel. Cost model for nearest neighbor search in high dimensional data space. In Proc. of Symposium on Principles of Database Systems, Tucson, Arizona, 1997.</ref>;

2) Для выделения множества сравнительно малых связных подграфов требуется <math>nm</math> операций, где <math>m</math> - количество подграфов, полученных на втором этапе алгоритма;

3) Формирование набора кластеров, на основе множества подграфов, полученных на предыдущем этапе, требует <math>m^2log(m)</math> операций.

Итого, для n вершин получаем последовательную сложность <math>O(n log(n)+nm+m^2log(m))</math>.

== Информационный граф ==
[[File:СК.png]]

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

Первый этап работы алгоритма можно распределить между <math>n</math> процессами. На вход каждому процессу подается своя вершина, далее происходит процедура поиска <math>k</math> ближайших соседей. Параллельная сложность составляет <math>O(n)</math>.

Второй и третий этапы можно распараллелить частично.

Второй этап распараллеливается путем подачи на вход свободному процессу очередного подграфа для разделения. Число итераций оценивается в <math>O(n log(n))</math>.

Третий этап делится на расчет показателей схожести и соединение подграфов в кластеры. Процесс расчета показателей можно распараллелить, подавая каждому процессу на вход пару подграфов. Сложность этого процесса оценивается как <math>m log(m)</math>. Соединение подграфов в кластеры выполняется последовательно, сложность процесса составляет <math>m^2 log(m)</math>

Таким образом получаем общую параллельную сложность алгоритма: <math>O(n+ n log(n) + m^2 log (m) + m log(m))</math>

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

1. Симметрическая матрица <math>A</math> расстояний между элементами данных размера <math>n\times n</math> с нулями на главной диагонали (<math>a_{ii}= 0, i = 1, \ldots, N</math>).

2. <math>k</math> - количество ближайших соседей для вершин (рекомендуемое значение <math>k</math> от 5 до 20 в зависимости от количества анализируемых объектов).

3. <math>l</math> - наименьшее число вершин, которое может содержать наибольший подкластер на 2-м этапе . Величина этого параметра варьируется от 1 до 5 % от общего числа объектов.

'''Объём входных данных'''

<math>\frac{n (n - 1)}{2}</math> (в силу симметричности и нулевой главной диагонали достаточно хранить только над/поддиагональные элементы).

'''Выходные данные'''

Вектор из <math>n</math> чисел <math>u_{1}, u_{2}, \ldots, u_{N}</math>, где <math>u_{i}</math> - целое число, соответствующее кластеру <math>i</math>-го объекта.

'''Объём выходных данных'''

<math>n</math>

== Свойства алгоритма ==
Соотношение последовательной и параллельной сложности на первом этапе является ''линейным'' для больших наборов данных и логарифмическим для n вершин. На втором этапе сложно оценить это соотношение - оно сильно зависит от параметров <math>k</math> и <math>l</math>. На третьем этапе соотношение равно <math>O(1)</math>

Оценка ''вычислительной мощности'' выглядит следующим образом:

<math>O(1)</math> для 1-го этапа

<math>O(\frac{nm}{n^2+m})</math> для 2-го этапа

<math>O(\frac{m^2log(m)}{m+n})</math> для 3-го этапа

Алгоритм является ''недетерминированным''. Хотя 1-й этап детерминирован, на 2-ом этапе могут быть найдены различные разбиения на подграфы, что повлияет и на итоговый результат работы алгоритма.

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

см. позднее

== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Последовательная реализация алгоритма доступна по ссылке <ref>http://www.codeforge.com/article/192925</ref>.

CHAMELEON можно реализовать с использованием графовых библиотек METIS <ref>http://glaros.dtc.umn.edu/gkhome/metis/metis/overview
</ref>, hMETIS <ref>http://glaros.dtc.umn.edu/gkhome/metis/hmetis/overview</ref> и RANN <ref>https://cran.r-project.org/web/packages/RANN/index.html</ref>.

Существует исследование, связанное с реализацией CHAMELEON посредством технологии OpenMP, с которым можно ознакомиться здесь <ref>http://research.ijcaonline.org/volume79/number8/pxc3891600.pdf</ref>.

Параллельных реализаций алгоритма CHAMELEON не найдено.

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

Участник:ЕкатеринаКозырева/Алгоритм динамической иерархической кластеризации CHAMELEON

2016-10-31T19:43:55Z

ЕкатеринаКозырева: /* Свойства алгоритма */

{{algorithm
| name = Алгоритм динамической иерархической кластеризации CHAMELEON
| serial_complexity = <math>O(nm + n log n + m^2 log m)</math>
| input_data = <math>\frac{n (n - 1)}{2}</math>
| output_data = <math>n</math>
| pf_height = <math>O(n+ n log(n) + m^2 log (m) + m log(m))</math>
| pf_width = <math>O(n)</math>
}}

Автор описания [[Участник:ЕкатеринаКозырева|Е.А.Козырева]]
= Свойства и структура алгоритмов =

== Общее описание алгоритма ==
Алгоритм CHAMELEON был предложен в 1999 году тремя учеными из университета Миннесоты – George Karypis, Eui-Hong (Sam) Han и Vipin Kumar<ref>George Karypis, Eui-Hong (Sam) Han и Vipin Kumar, «Chameleon: Hierarchical Clustering Using Dynamic Modeling», 1999.</ref>.

Предназначен для решения задач кластеризации. Кластеризация (или кластерный анализ) — это задача разбиения множества объектов на группы, называемые кластерами. Внутри каждой группы должны оказаться «похожие» объекты, а объекты разных группы должны быть как можно более отличны.

CHAMELEON - это агломеративный иерархический алгоритм кластеризации, ключевой особенностью которого является то, что он учитывает и взаимную связность, и сходство при определении наиболее похожей пары подкластеров, основываясь на динамической модели. Это означает, что в процессе кластеризации два кластера объединяются, только если их относительная взаимная связность и относительное взаимное сходство являются высокими по отношению к внутренней взаимосвязанности кластеров и близости элементов внутри кластеров. Кроме того, CHAMELEON использует подход для моделирования степени взаимосвязанности и близости между каждой парой кластеров, который учитывает внутренние характеристики самих кластеров. Таким образом, он может автоматически адаптироваться к внутренним характеристикам объединяемых кластеров.

CHAMELEON находит кластеры в наборе данных с помощью трехфазного алгоритма. На первой фазе происходит построение графа, путём добавления рёбер по принципу k ближайших соседей. На второй фазе CHAMELEON группирует полученные элементы в множество относительно небольших подграфов. Во время третьей фазы применяется агломеративный иерархический алгоритм кластеризации, с помощью которого находятся естесственные кластеры путем многократного объединения подграфов, полученных на прошлом этапе.

[[File:Chameleon.png|1000px|thumb|center|Рисунок 1. Общая структура алгоритма CHAMELEON]]

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

''Исходные данные'':

* Множество из n точек <math>V= {v_{ij}}</math> в метрическом пространстве, которое задано симметрической матрицей расстояний <math>A</math> размера <math>n\times n</math>.
* <math>k</math> - количество ближайших соседей для вершин, <math>k \in N, k \leq n</math>.
* <math>l</math> - наименьшее число вершин, которое может содержать наибольший подграф на 2-м этапе, <math>l \in N, l \leq n</math>.

''Обозначения'':

* <math>G = (V, E)</math> - граф, полученный путём соединения каждой точки с её <math>k</math> ближайшими соседями.

* <math>K= \{K_{i}\}</math> - разбиение множества <math>V</math> на набор попарно непересекающихся связных подмножеств, полученное в результате выполнения второй фазы алгоритма.

* <math>G_{2} = (K, E_{2})</math> - взвешенный граф, вершинами которого являются получившиеся подграфы, а ребрами - количество ребер исходного графа, соединяющих соответствующие подграфы.

* <math>C = \{C_{i}\}</math> - итоговое разбиение множества вершин графа <math>G_{2}</math> на набор кластеров.

''Вспомогательные понятия''

*<math>EC_{(C_{i},C_{j})}</math> - абсолютная взаимная связность пары кластеров <math>C_{i}, C{j}</math>. Определяется как сумма весов ребер, соединяющих вершины, принадлежащие <math>C{i}</math> c вершинами из <math>C{j}</math>. Внутренняя связность <math>EC_{(C_{i},C_{i})}</math> вычисляется как сумма ребер, входящих в разделитель, разбивающий <math>C{i}</math> на два равных подграфа.

*<math>RI_{(C_{i},C_{j})} = \frac{|EC_{(C_{i},C_{j})}|}{(|EC_{C_{i}}|+|EC_{C_{j}}|)/2}</math> - относительная взаимная связность пары кластеров <math>C_{i}, C{j}</math>

*<math>S_{EC_{(C_{i},C_{j})}}</math> - абсолютное взаимное сходство пары кластеров <math>C_{i}, C{j}</math>. Подсчитывается как среднее сходство между соединенными вершинами, принадлежащими <math>C{i}</math> и <math>C{j}</math> соответственно. Соединения обусловлены разбиением общего графа, полученного на первом этапе алгоритма.

*<math> RC_{(C_{i},C_{j})}= \frac{S_{EC_{(C_{i},C_{j})}}}{\frac{|C_{i}|}{|C_{i}+C_{j}|}*S_{EC_{(C_{i})}}+\frac{|C_{i}|}{|C_{i}+C_{j}|}*S_{EC_{(C_{j})}}}</math> - относительное взаимное сходство пары кластеров <math>C_{i}, C{j}</math>. Определяется как абсолютное сходство между этой парой кластеров, нормализованное с учетом их внутреннего сходства<ref>http://studopedia.ru/7_41934_algoritm-dinamicheskoy-ierarhicheskoy-klasterizatsii-CHAMELEON.html</ref>.

'''Первый этап'''

На первом этапе, согласно графо-ориентированному подходу, происходит построение графа <math>G = (V, E)</math> на матрице сходства объектов по принципу k ближайших соседей. Две вершины такого графа соединяет ребро, если объект, соответствующий любой из этих вершин попадает в число k наиболее близких объектов для объекта, соответствующего другой вершине из данной пары.
[[Файл:Снимок chameleon 2.png|2000px|thumb|Рисунок 2. Объекты в пространстве - слева, граф по принципу 1-го ближайшего соседа - по центру, граф по принципу 3-х ближайших соседей - справа ]]

'''Второй этап'''

Алгоритм разделяет полученный граф на множество сравнительно малых подграфов <math>K= \{K_{i}\}</math>. Разделение происходит последовательно. На каждом шаге выбирается подграф, содержащий наибольшее число вершин. Этот граф разделяется на два подграфа так, что разделитель ребер графа минимален и каждый из получаемых подграфов содержит не менее 25 % вершин исходного графа. Процесс разделения останавливается, когда наибольший подграф содержит меньше некоторого заданного числа вершин. Обычно величина этого параметра задается равной значению от 1 до 5 % от числа объектов. Полученное множество связных графов считается множеством начальных кластеров, на котором требуется провести последовательное иерархическое объединение.

'''Третий этап'''

Третий этап заключается в итеративном преобразовании множества подграфов <math>K= \{K_{i}\}</math> в множество кластеров <math>C = \{C_{i}\}</math>. Алгоритм осуществляет агломеративную иерархическую кластеризацию на основании показателей <math>EC_{(C_{i},C_{j})}</math>, <math>S_{EC_{(C_{i},C_{j})}}</math>, <math>RI_{(C_{i},C_{j})} </math>, <math> RC_{(C_{i},C_{j})}</math>. Существует две стратегии анализа показателей сходства. Первая подразумевает наличие некоторых пороговых значений <math>T_{RI}</math> и <math>T_{RC}</math>. В соответствии с этой стратегией, алгоритм для каждого кластера <math>C_{i}</math> проверяет, отвечают ли смежные (наиболее близкие) ему кластеры условиям:

*<math>RI_{(C_{i},C_{j})} \geqslant T_{RI}</math>

*<math>RC_{(C_{i},C_{j})} \geqslant T_{RC}</math>

Если более одного смежного кластера отвечает этим условиям, то алгоритм выбирает для объединения наиболее связный кластер (граф), то есть такой кластер <math>C_{j}</math>, с которым у кластера <math>C_{i}</math> получается наибольшая абсолютная взаимная связность. По завершению прохода по всем кластерам, созданные таким образом пары объединяются. Параметры <math>T_{RI}</math> и <math>T_{RC}</math> могут использоваться для изменения характеристик получаемых кластеров.

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

<math>RI_{(C_{i},C_{j})}*RC_{(C_{i},C_{j})}^\alpha</math>,

где <math>\alpha</math> выбирается пользователем. Если <math>\alpha > 1 </math>, то алгоритм придает большее значение относительному взаимному сходству, а если <math>\alpha < 1 </math>, то большее значение имеет относительная взаимная связность.

''Вычисляемые данные'':

<math>U = (u_1, u_2, ..., u_n)</math> - n-мерный вектор, где <math>u_i \in N_{[C]}</math> - порядковый номер кластера, к которому принадлежит вершина i исходного множества V.

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

Алгоритм имеет три вычислительных ядра, по одному на каждый этап.

На первом этапе вычислительным ядром является процесс нахождения <math>k</math> ближайших соседей для каждой вершины, который заключается в анализе матрицы расстояний.

На втором этапе вычислительным ядром является процесс поиска подходящего разбиения очередного подграфа на два графа с минимизацией разделителя ребер графа.

На третьем этапе вычислительным ядром является расчет величин <math>EC_{(C_{i},C_{j})}</math>, <math>S_{EC_{(C_{i},C_{j})}}</math>, <math>RI_{(C_{i},C_{j})} </math>, <math> RC_{(C_{i},C_{j})}</math> для каждой пары смежных кластеров.

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

Как уже рассказывалось ранее, алгоритм включает в себя три основных этапа, каждый из которых, по сути, является отдельным алгоритмом. Этапы выполняются последовательно относительно друг друга.

Макрооперация на первом этапе - процедура нахождения <math>k</math> ближайших соседей, на втором - процедура разбиения наибольшего подграфа на два графа, на третьем - процедура вычисления показателей сходства, на основе которых принимается решение о слиянии подграфов в кластер.

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

'''Первый этап'''
<source lang="cpp">
int n; //количество вершин
int k; //количество соседей
int A[n][n] //матрица расстояний
int D[k] //массив вершин-соседей
int E[n][n] //матрица ребер графа <math>G_{2} = (K, E_{2})</math>
for i=1 to n-1 do
{
for j=i+1 to n do
{
//заполняем массив вершин-соседей вставляя новые вершины, если они ближе, чем самая далекая из массива.
}
for j=0 to k do
{
//для каждой вершины соседа заполняем соответствующую ячейку из матрицы E[n][n] единицей
}

}
</source>

'''Второй этап'''

1. Все связные подграфы в отсортированном порядке помещаются в список;
2. Берем наибольший элемент списка, вычисляем количество его вершин. Если число вершин > l, то идем в пункт 3. Иначе в пункт 5;
3. Разбиваем подграф на два подграфа таким образом, чтобы разделитель ребер графа был минимален и каждый из получаемых подграфов содержал не менее 25 % вершин исходного графа;
4. Добавляем полученные элементы в список подграфов таким образом, чтобы список оставался отсортированным. Идем в пункт 2;
5. Нашли искомое множество подграфов math>K = \{K_{i}\}</math>;
6. Создаем и заполняем матрицу матрицу расстояний для графа <math>G_{2} = (K, E_{2})</math>. Получаем искомый набор рёбер <math>E_{2}</math>.

'''Третий этап'''

1. Заводим два массива: а) массив кластеров C, полученных на предыдущем этапе, б) массив объединений кластеров F, которые мы будем получать на этом этапе;
2. Берем следующий кластер <math>C_{i}</math> (на первом шаге - первый). Если все кластеры просмотрены, идем в пункт 6;
3. Берем следующий кластер <math>C_{j}, i<>j</math>. Если все кластеры просмотрены, то идем в пункт 2;
4. Проверяем смежность <math>C_{i}</math> и <math>C_{j}</math>. Если не смежны, то возвращаемся в пункт 3. Если смежны, идем в пункт 5;
5. Рассчитываем показатели <math>RI_{(C_{i},C_{j})}</math> и <math> RC_{(C_{i},C_{j})}</math>. Проверяем, удовлетворяют ли найденные значения условиям:
*<math>RI_{(C_{i},C_{j})} \geqslant T_{RI}</math>
*<math>RC_{(C_{i},C_{j})} \geqslant T_{RC}</math>
Если нет, то идем в пункт 3. Иначе если смежность пары кластеров выше, чем у предыдущих найденных, то <math>F_{i}=j</math>. Идем в пункт 3;
6. Если в списке F есть хотя бы одна пара кластеров для слияния, то выполняем слияние, обновляем массив кластеров и массив объединений кластеров. Идем в пункт 2.

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

1) Для построения графа на основе метода k ближайших соседей для n вершин требуется <math>O(n log(n))</math> операций <ref>J.H. Friedman, J.L. Bentley, and R.A. Finkel. An algorithm for ﬁnding best matches in logarithmic expected time. ACM Transactions on Mathematical Software, 3:209–226, 1977.</ref>; для наборов данных большой размерности эта величина составляет <math>O(n^2)</math> операций <ref>S. Berchtold, C. Bohm, D. Keim, and H.-P. Kriegel. Cost model for nearest neighbor search in high dimensional data space. In Proc. of Symposium on Principles of Database Systems, Tucson, Arizona, 1997.</ref>;

2) Для выделения множества сравнительно малых связных подграфов требуется <math>nm</math> операций, где <math>m</math> - количество подграфов, полученных на втором этапе алгоритма;

3) Формирование набора кластеров, на основе множества подграфов, полученных на предыдущем этапе, требует <math>m^2log(m)</math> операций.

Итого, для n вершин получаем последовательную сложность <math>O(n log(n)+nm+m^2log(m))</math>.

== Информационный граф ==
[[File:СК.png]]

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

Первый этап работы алгоритма можно распределить между <math>n</math> процессами. На вход каждому процессу подается своя вершина, далее происходит процедура поиска <math>k</math> ближайших соседей. Параллельная сложность составляет <math>O(n)</math>.

Второй и третий этапы можно распараллелить частично.

Второй этап распараллеливается путем подачи на вход свободному процессу очередного подграфа для разделения. Число итераций оценивается в <math>O(n log(n))</math>.

Третий этап делится на расчет показателей схожести и соединение подграфов в кластеры. Процесс расчета показателей можно распараллелить, подавая каждому процессу на вход пару подграфов. Сложность этого процесса оценивается как <math>m log(m)</math>. Соединение подграфов в кластеры выполняется последовательно, сложность процесса составляет <math>m^2 log(m)</math>

Таким образом получаем общую параллельную сложность алгоритма: <math>O(n+ n log(n) + m^2 log (m) + m log(m))</math>

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

1. Симметрическая матрица <math>A</math> расстояний между элементами данных размера <math>n\times n</math> с нулями на главной диагонали (<math>a_{ii}= 0, i = 1, \ldots, N</math>).

2. <math>k</math> - количество ближайших соседей для вершин (рекомендуемое значение <math>k</math> от 5 до 20 в зависимости от количества анализируемых объектов).

3. <math>l</math> - наименьшее число вершин, которое может содержать наибольший подкластер на 2-м этапе . Величина этого параметра варьируется от 1 до 5 % от общего числа объектов.

'''Объём входных данных'''

<math>\frac{n (n - 1)}{2}</math> (в силу симметричности и нулевой главной диагонали достаточно хранить только над/поддиагональные элементы).

'''Выходные данные'''

Вектор из <math>n</math> чисел <math>u_{1}, u_{2}, \ldots, u_{N}</math>, где <math>u_{i}</math> - целое число, соответствующее кластеру <math>i</math>-го объекта.

'''Объём выходных данных'''

<math>n</math>

== Свойства алгоритма ==
Соотношение последовательной и параллельной сложности на первом этапе является ''линейным'' для больших наборов данных и логарифмическим для n вершин. На втором этапе сложно оценить это соотношение - оно сильно зависит от параметров <math>k</math> и <math>l</math>. На третьем этапе соотношение равно <math>O(1)</math>

Оценка ''вычислительной мощности'' выглядит следующим образом:

<math>O(1)</math> для 1-го этапа

<math>O(\frac{nm}{n^2+m})</math> для 2-го этапа

<math>O(\frac{m^2log(m)}{m+n})</math> для 3-го этапа

Алгоритм является ''недетерминированным''. Хотя 1-й этап детерминирован, на 2-ом этапе могут быть найдены различные разбиения на подграфы, что повлияет и на итоговый результат работы алгоритма.

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

см. позднее

== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Последовательная реализация алгоритма доступна по ссылке <ref>http://www.codeforge.com/article/192925</ref>.

CHAMELEON можно реализовать с использованием графовых библиотек METIS <ref>http://glaros.dtc.umn.edu/gkhome/metis/metis/overview
</ref>, hMETIS <ref>http://glaros.dtc.umn.edu/gkhome/metis/hmetis/overview</ref> и RANN <ref>https://cran.r-project.org/web/packages/RANN/index.html</ref>.

Существует исследование, связанное с реализацией CHAMELEON посредством технологии OpenMP, с которым можно ознакомиться здесь <ref>http://research.ijcaonline.org/volume79/number8/pxc3891600.pdf</ref>.

Параллельных реализаций алгоритма CHAMELEON не найдено.

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

Участник:ЕкатеринаКозырева/Алгоритм динамической иерархической кластеризации CHAMELEON

2016-10-31T18:57:27Z

ЕкатеринаКозырева: /* Литература */

{{algorithm
| name = Алгоритм динамической иерархической кластеризации CHAMELEON
| serial_complexity = <math>O(nm + n log n + m^2 log m)</math>
| input_data = <math>\frac{n (n - 1)}{2}</math>
| output_data = <math>n</math>
| pf_height = <math>O(n+ n log(n) + m^2 log (m) + m log(m))</math>
| pf_width = <math>O(n)</math>
}}

Автор описания [[Участник:ЕкатеринаКозырева|Е.А.Козырева]]
= Свойства и структура алгоритмов =

== Общее описание алгоритма ==
Алгоритм CHAMELEON был предложен в 1999 году тремя учеными из университета Миннесоты – George Karypis, Eui-Hong (Sam) Han и Vipin Kumar<ref>George Karypis, Eui-Hong (Sam) Han и Vipin Kumar, «Chameleon: Hierarchical Clustering Using Dynamic Modeling», 1999.</ref>.

Предназначен для решения задач кластеризации. Кластеризация (или кластерный анализ) — это задача разбиения множества объектов на группы, называемые кластерами. Внутри каждой группы должны оказаться «похожие» объекты, а объекты разных группы должны быть как можно более отличны.

CHAMELEON - это агломеративный иерархический алгоритм кластеризации, ключевой особенностью которого является то, что он учитывает и взаимную связность, и сходство при определении наиболее похожей пары подкластеров, основываясь на динамической модели. Это означает, что в процессе кластеризации два кластера объединяются, только если их относительная взаимная связность и относительное взаимное сходство являются высокими по отношению к внутренней взаимосвязанности кластеров и близости элементов внутри кластеров. Кроме того, CHAMELEON использует подход для моделирования степени взаимосвязанности и близости между каждой парой кластеров, который учитывает внутренние характеристики самих кластеров. Таким образом, он может автоматически адаптироваться к внутренним характеристикам объединяемых кластеров.

CHAMELEON находит кластеры в наборе данных с помощью трехфазного алгоритма. На первой фазе происходит построение графа, путём добавления рёбер по принципу k ближайших соседей. На второй фазе CHAMELEON группирует полученные элементы в множество относительно небольших подграфов. Во время третьей фазы применяется агломеративный иерархический алгоритм кластеризации, с помощью которого находятся естесственные кластеры путем многократного объединения подграфов, полученных на прошлом этапе.

[[File:Chameleon.png|1000px|thumb|center|Рисунок 1. Общая структура алгоритма CHAMELEON]]

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

''Исходные данные'':

* Множество из n точек <math>V= {v_{ij}}</math> в метрическом пространстве, которое задано симметрической матрицей расстояний <math>A</math> размера <math>n\times n</math>.
* <math>k</math> - количество ближайших соседей для вершин, <math>k \in N, k \leq n</math>.
* <math>l</math> - наименьшее число вершин, которое может содержать наибольший подграф на 2-м этапе, <math>l \in N, l \leq n</math>.

''Обозначения'':

* <math>G = (V, E)</math> - граф, полученный путём соединения каждой точки с её <math>k</math> ближайшими соседями.

* <math>K= \{K_{i}\}</math> - разбиение множества <math>V</math> на набор попарно непересекающихся связных подмножеств, полученное в результате выполнения второй фазы алгоритма.

* <math>G_{2} = (K, E_{2})</math> - взвешенный граф, вершинами которого являются получившиеся подграфы, а ребрами - количество ребер исходного графа, соединяющих соответствующие подграфы.

* <math>C = \{C_{i}\}</math> - итоговое разбиение множества вершин графа <math>G_{2}</math> на набор кластеров.

''Вспомогательные понятия''

*<math>EC_{(C_{i},C_{j})}</math> - абсолютная взаимная связность пары кластеров <math>C_{i}, C{j}</math>. Определяется как сумма весов ребер, соединяющих вершины, принадлежащие <math>C{i}</math> c вершинами из <math>C{j}</math>. Внутренняя связность <math>EC_{(C_{i},C_{i})}</math> вычисляется как сумма ребер, входящих в разделитель, разбивающий <math>C{i}</math> на два равных подграфа.

*<math>RI_{(C_{i},C_{j})} = \frac{|EC_{(C_{i},C_{j})}|}{(|EC_{C_{i}}|+|EC_{C_{j}}|)/2}</math> - относительная взаимная связность пары кластеров <math>C_{i}, C{j}</math>

*<math>S_{EC_{(C_{i},C_{j})}}</math> - абсолютное взаимное сходство пары кластеров <math>C_{i}, C{j}</math>. Подсчитывается как среднее сходство между соединенными вершинами, принадлежащими <math>C{i}</math> и <math>C{j}</math> соответственно. Соединения обусловлены разбиением общего графа, полученного на первом этапе алгоритма.

*<math> RC_{(C_{i},C_{j})}= \frac{S_{EC_{(C_{i},C_{j})}}}{\frac{|C_{i}|}{|C_{i}+C_{j}|}*S_{EC_{(C_{i})}}+\frac{|C_{i}|}{|C_{i}+C_{j}|}*S_{EC_{(C_{j})}}}</math> - относительное взаимное сходство пары кластеров <math>C_{i}, C{j}</math>. Определяется как абсолютное сходство между этой парой кластеров, нормализованное с учетом их внутреннего сходства<ref>http://studopedia.ru/7_41934_algoritm-dinamicheskoy-ierarhicheskoy-klasterizatsii-CHAMELEON.html</ref>.

'''Первый этап'''

На первом этапе, согласно графо-ориентированному подходу, происходит построение графа <math>G = (V, E)</math> на матрице сходства объектов по принципу k ближайших соседей. Две вершины такого графа соединяет ребро, если объект, соответствующий любой из этих вершин попадает в число k наиболее близких объектов для объекта, соответствующего другой вершине из данной пары.
[[Файл:Снимок chameleon 2.png|2000px|thumb|Рисунок 2. Объекты в пространстве - слева, граф по принципу 1-го ближайшего соседа - по центру, граф по принципу 3-х ближайших соседей - справа ]]

'''Второй этап'''

Алгоритм разделяет полученный граф на множество сравнительно малых подграфов <math>K= \{K_{i}\}</math>. Разделение происходит последовательно. На каждом шаге выбирается подграф, содержащий наибольшее число вершин. Этот граф разделяется на два подграфа так, что разделитель ребер графа минимален и каждый из получаемых подграфов содержит не менее 25 % вершин исходного графа. Процесс разделения останавливается, когда наибольший подграф содержит меньше некоторого заданного числа вершин. Обычно величина этого параметра задается равной значению от 1 до 5 % от числа объектов. Полученное множество связных графов считается множеством начальных кластеров, на котором требуется провести последовательное иерархическое объединение.

'''Третий этап'''

Третий этап заключается в итеративном преобразовании множества подграфов <math>K= \{K_{i}\}</math> в множество кластеров <math>C = \{C_{i}\}</math>. Алгоритм осуществляет агломеративную иерархическую кластеризацию на основании показателей <math>EC_{(C_{i},C_{j})}</math>, <math>S_{EC_{(C_{i},C_{j})}}</math>, <math>RI_{(C_{i},C_{j})} </math>, <math> RC_{(C_{i},C_{j})}</math>. Существует две стратегии анализа показателей сходства. Первая подразумевает наличие некоторых пороговых значений <math>T_{RI}</math> и <math>T_{RC}</math>. В соответствии с этой стратегией, алгоритм для каждого кластера <math>C_{i}</math> проверяет, отвечают ли смежные (наиболее близкие) ему кластеры условиям:

*<math>RI_{(C_{i},C_{j})} \geqslant T_{RI}</math>

*<math>RC_{(C_{i},C_{j})} \geqslant T_{RC}</math>

Если более одного смежного кластера отвечает этим условиям, то алгоритм выбирает для объединения наиболее связный кластер (граф), то есть такой кластер <math>C_{j}</math>, с которым у кластера <math>C_{i}</math> получается наибольшая абсолютная взаимная связность. По завершению прохода по всем кластерам, созданные таким образом пары объединяются. Параметры <math>T_{RI}</math> и <math>T_{RC}</math> могут использоваться для изменения характеристик получаемых кластеров.

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

<math>RI_{(C_{i},C_{j})}*RC_{(C_{i},C_{j})}^\alpha</math>,

где <math>\alpha</math> выбирается пользователем. Если <math>\alpha > 1 </math>, то алгоритм придает большее значение относительному взаимному сходству, а если <math>\alpha < 1 </math>, то большее значение имеет относительная взаимная связность.

''Вычисляемые данные'':

<math>U = (u_1, u_2, ..., u_n)</math> - n-мерный вектор, где <math>u_i \in N_{[C]}</math> - порядковый номер кластера, к которому принадлежит вершина i исходного множества V.

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

Алгоритм имеет три вычислительных ядра, по одному на каждый этап.

На первом этапе вычислительным ядром является процесс нахождения <math>k</math> ближайших соседей для каждой вершины, который заключается в анализе матрицы расстояний.

На втором этапе вычислительным ядром является процесс поиска подходящего разбиения очередного подграфа на два графа с минимизацией разделителя ребер графа.

На третьем этапе вычислительным ядром является расчет величин <math>EC_{(C_{i},C_{j})}</math>, <math>S_{EC_{(C_{i},C_{j})}}</math>, <math>RI_{(C_{i},C_{j})} </math>, <math> RC_{(C_{i},C_{j})}</math> для каждой пары смежных кластеров.

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

Как уже рассказывалось ранее, алгоритм включает в себя три основных этапа, каждый из которых, по сути, является отдельным алгоритмом. Этапы выполняются последовательно относительно друг друга.

Макрооперация на первом этапе - процедура нахождения <math>k</math> ближайших соседей, на втором - процедура разбиения наибольшего подграфа на два графа, на третьем - процедура вычисления показателей сходства, на основе которых принимается решение о слиянии подграфов в кластер.

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

'''Первый этап'''
<source lang="cpp">
int n; //количество вершин
int k; //количество соседей
int A[n][n] //матрица расстояний
int D[k] //массив вершин-соседей
int E[n][n] //матрица ребер графа <math>G_{2} = (K, E_{2})</math>
for i=1 to n-1 do
{
for j=i+1 to n do
{
//заполняем массив вершин-соседей вставляя новые вершины, если они ближе, чем самая далекая из массива.
}
for j=0 to k do
{
//для каждой вершины соседа заполняем соответствующую ячейку из матрицы E[n][n] единицей
}

}
</source>

'''Второй этап'''

1. Все связные подграфы в отсортированном порядке помещаются в список;
2. Берем наибольший элемент списка, вычисляем количество его вершин. Если число вершин > l, то идем в пункт 3. Иначе в пункт 5;
3. Разбиваем подграф на два подграфа таким образом, чтобы разделитель ребер графа был минимален и каждый из получаемых подграфов содержал не менее 25 % вершин исходного графа;
4. Добавляем полученные элементы в список подграфов таким образом, чтобы список оставался отсортированным. Идем в пункт 2;
5. Нашли искомое множество подграфов math>K = \{K_{i}\}</math>;
6. Создаем и заполняем матрицу матрицу расстояний для графа <math>G_{2} = (K, E_{2})</math>. Получаем искомый набор рёбер <math>E_{2}</math>.

'''Третий этап'''

1. Заводим два массива: а) массив кластеров C, полученных на предыдущем этапе, б) массив объединений кластеров F, которые мы будем получать на этом этапе;
2. Берем следующий кластер <math>C_{i}</math> (на первом шаге - первый). Если все кластеры просмотрены, идем в пункт 6;
3. Берем следующий кластер <math>C_{j}, i<>j</math>. Если все кластеры просмотрены, то идем в пункт 2;
4. Проверяем смежность <math>C_{i}</math> и <math>C_{j}</math>. Если не смежны, то возвращаемся в пункт 3. Если смежны, идем в пункт 5;
5. Рассчитываем показатели <math>RI_{(C_{i},C_{j})}</math> и <math> RC_{(C_{i},C_{j})}</math>. Проверяем, удовлетворяют ли найденные значения условиям:
*<math>RI_{(C_{i},C_{j})} \geqslant T_{RI}</math>
*<math>RC_{(C_{i},C_{j})} \geqslant T_{RC}</math>
Если нет, то идем в пункт 3. Иначе если смежность пары кластеров выше, чем у предыдущих найденных, то <math>F_{i}=j</math>. Идем в пункт 3;
6. Если в списке F есть хотя бы одна пара кластеров для слияния, то выполняем слияние, обновляем массив кластеров и массив объединений кластеров. Идем в пункт 2.

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

1) Для построения графа на основе метода k ближайших соседей для n вершин требуется <math>O(n log(n))</math> операций <ref>J.H. Friedman, J.L. Bentley, and R.A. Finkel. An algorithm for ﬁnding best matches in logarithmic expected time. ACM Transactions on Mathematical Software, 3:209–226, 1977.</ref>; для наборов данных большой размерности эта величина составляет <math>O(n^2)</math> операций <ref>S. Berchtold, C. Bohm, D. Keim, and H.-P. Kriegel. Cost model for nearest neighbor search in high dimensional data space. In Proc. of Symposium on Principles of Database Systems, Tucson, Arizona, 1997.</ref>;

2) Для выделения множества сравнительно малых связных подграфов требуется <math>nm</math> операций, где <math>m</math> - количество подграфов, полученных на втором этапе алгоритма;

3) Формирование набора кластеров, на основе множества подграфов, полученных на предыдущем этапе, требует <math>m^2log(m)</math> операций.

Итого, для n вершин получаем последовательную сложность <math>O(n log(n)+nm+m^2log(m))</math>.

== Информационный граф ==
[[File:СК.png]]

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

Первый этап работы алгоритма можно распределить между <math>n</math> процессами. На вход каждому процессу подается своя вершина, далее происходит процедура поиска <math>k</math> ближайших соседей. Параллельная сложность составляет <math>O(n)</math>.

Второй и третий этапы можно распараллелить частично.

Второй этап распараллеливается путем подачи на вход свободному процессу очередного подграфа для разделения. Число итераций оценивается в <math>O(n log(n))</math>.

Третий этап делится на расчет показателей схожести и соединение подграфов в кластеры. Процесс расчета показателей можно распараллелить, подавая каждому процессу на вход пару подграфов. Сложность этого процесса оценивается как <math>m log(m)</math>. Соединение подграфов в кластеры выполняется последовательно, сложность процесса составляет <math>m^2 log(m)</math>

Таким образом получаем общую параллельную сложность алгоритма: <math>O(n+ n log(n) + m^2 log (m) + m log(m))</math>

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

1. Симметрическая матрица <math>A</math> расстояний между элементами данных размера <math>n\times n</math> с нулями на главной диагонали (<math>a_{ii}= 0, i = 1, \ldots, N</math>).

2. <math>k</math> - количество ближайших соседей для вершин (рекомендуемое значение <math>k</math> от 5 до 20 в зависимости от количества анализируемых объектов).

3. <math>l</math> - наименьшее число вершин, которое может содержать наибольший подкластер на 2-м этапе . Величина этого параметра варьируется от 1 до 5 % от общего числа объектов.

'''Объём входных данных'''

<math>\frac{n (n - 1)}{2}</math> (в силу симметричности и нулевой главной диагонали достаточно хранить только над/поддиагональные элементы).

'''Выходные данные'''

Вектор из <math>n</math> чисел <math>u_{1}, u_{2}, \ldots, u_{N}</math>, где <math>u_{i}</math> - целое число, соответствующее кластеру <math>i</math>-го объекта.

'''Объём выходных данных'''

<math>n</math>

== Свойства алгоритма ==
Соотношение последовательной и параллельной сложности на первом этапе является ''линейным'' для больших наборов данных и логарифмическим для n вершин. На втором этапе сложно оценить это соотношение - оно сильно зависит от параметров <math>k</math> и <math>l</math>. На третьем этапе соотношение равно <math>O(1)</math>

Алгоритм является недетерминированным. Хотя 1-й этап детерминирован, на 2-ом этапе могут быть найдены различные разбиения на подграфы, что повлияет и на итоговый результат работы алгоритма.

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

см. позднее

== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Последовательная реализация алгоритма доступна по ссылке <ref>http://www.codeforge.com/article/192925</ref>.

CHAMELEON можно реализовать с использованием графовых библиотек METIS <ref>http://glaros.dtc.umn.edu/gkhome/metis/metis/overview
</ref>, hMETIS <ref>http://glaros.dtc.umn.edu/gkhome/metis/hmetis/overview</ref> и RANN <ref>https://cran.r-project.org/web/packages/RANN/index.html</ref>.

Существует исследование, связанное с реализацией CHAMELEON посредством технологии OpenMP, с которым можно ознакомиться здесь <ref>http://research.ijcaonline.org/volume79/number8/pxc3891600.pdf</ref>.

Параллельных реализаций алгоритма CHAMELEON не найдено.

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

Участник:ЕкатеринаКозырева/Алгоритм динамической иерархической кластеризации CHAMELEON

2016-10-31T18:57:12Z

ЕкатеринаКозырева: /* Последовательная сложность алгоритма */

{{algorithm
| name = Алгоритм динамической иерархической кластеризации CHAMELEON
| serial_complexity = <math>O(nm + n log n + m^2 log m)</math>
| input_data = <math>\frac{n (n - 1)}{2}</math>
| output_data = <math>n</math>
| pf_height = <math>O(n+ n log(n) + m^2 log (m) + m log(m))</math>
| pf_width = <math>O(n)</math>
}}

Автор описания [[Участник:ЕкатеринаКозырева|Е.А.Козырева]]
= Свойства и структура алгоритмов =

== Общее описание алгоритма ==
Алгоритм CHAMELEON был предложен в 1999 году тремя учеными из университета Миннесоты – George Karypis, Eui-Hong (Sam) Han и Vipin Kumar<ref>George Karypis, Eui-Hong (Sam) Han и Vipin Kumar, «Chameleon: Hierarchical Clustering Using Dynamic Modeling», 1999.</ref>.

Предназначен для решения задач кластеризации. Кластеризация (или кластерный анализ) — это задача разбиения множества объектов на группы, называемые кластерами. Внутри каждой группы должны оказаться «похожие» объекты, а объекты разных группы должны быть как можно более отличны.

CHAMELEON - это агломеративный иерархический алгоритм кластеризации, ключевой особенностью которого является то, что он учитывает и взаимную связность, и сходство при определении наиболее похожей пары подкластеров, основываясь на динамической модели. Это означает, что в процессе кластеризации два кластера объединяются, только если их относительная взаимная связность и относительное взаимное сходство являются высокими по отношению к внутренней взаимосвязанности кластеров и близости элементов внутри кластеров. Кроме того, CHAMELEON использует подход для моделирования степени взаимосвязанности и близости между каждой парой кластеров, который учитывает внутренние характеристики самих кластеров. Таким образом, он может автоматически адаптироваться к внутренним характеристикам объединяемых кластеров.

CHAMELEON находит кластеры в наборе данных с помощью трехфазного алгоритма. На первой фазе происходит построение графа, путём добавления рёбер по принципу k ближайших соседей. На второй фазе CHAMELEON группирует полученные элементы в множество относительно небольших подграфов. Во время третьей фазы применяется агломеративный иерархический алгоритм кластеризации, с помощью которого находятся естесственные кластеры путем многократного объединения подграфов, полученных на прошлом этапе.

[[File:Chameleon.png|1000px|thumb|center|Рисунок 1. Общая структура алгоритма CHAMELEON]]

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

''Исходные данные'':

* Множество из n точек <math>V= {v_{ij}}</math> в метрическом пространстве, которое задано симметрической матрицей расстояний <math>A</math> размера <math>n\times n</math>.
* <math>k</math> - количество ближайших соседей для вершин, <math>k \in N, k \leq n</math>.
* <math>l</math> - наименьшее число вершин, которое может содержать наибольший подграф на 2-м этапе, <math>l \in N, l \leq n</math>.

''Обозначения'':

* <math>G = (V, E)</math> - граф, полученный путём соединения каждой точки с её <math>k</math> ближайшими соседями.

* <math>K= \{K_{i}\}</math> - разбиение множества <math>V</math> на набор попарно непересекающихся связных подмножеств, полученное в результате выполнения второй фазы алгоритма.

* <math>G_{2} = (K, E_{2})</math> - взвешенный граф, вершинами которого являются получившиеся подграфы, а ребрами - количество ребер исходного графа, соединяющих соответствующие подграфы.

* <math>C = \{C_{i}\}</math> - итоговое разбиение множества вершин графа <math>G_{2}</math> на набор кластеров.

''Вспомогательные понятия''

*<math>EC_{(C_{i},C_{j})}</math> - абсолютная взаимная связность пары кластеров <math>C_{i}, C{j}</math>. Определяется как сумма весов ребер, соединяющих вершины, принадлежащие <math>C{i}</math> c вершинами из <math>C{j}</math>. Внутренняя связность <math>EC_{(C_{i},C_{i})}</math> вычисляется как сумма ребер, входящих в разделитель, разбивающий <math>C{i}</math> на два равных подграфа.

*<math>RI_{(C_{i},C_{j})} = \frac{|EC_{(C_{i},C_{j})}|}{(|EC_{C_{i}}|+|EC_{C_{j}}|)/2}</math> - относительная взаимная связность пары кластеров <math>C_{i}, C{j}</math>

*<math>S_{EC_{(C_{i},C_{j})}}</math> - абсолютное взаимное сходство пары кластеров <math>C_{i}, C{j}</math>. Подсчитывается как среднее сходство между соединенными вершинами, принадлежащими <math>C{i}</math> и <math>C{j}</math> соответственно. Соединения обусловлены разбиением общего графа, полученного на первом этапе алгоритма.

*<math> RC_{(C_{i},C_{j})}= \frac{S_{EC_{(C_{i},C_{j})}}}{\frac{|C_{i}|}{|C_{i}+C_{j}|}*S_{EC_{(C_{i})}}+\frac{|C_{i}|}{|C_{i}+C_{j}|}*S_{EC_{(C_{j})}}}</math> - относительное взаимное сходство пары кластеров <math>C_{i}, C{j}</math>. Определяется как абсолютное сходство между этой парой кластеров, нормализованное с учетом их внутреннего сходства<ref>http://studopedia.ru/7_41934_algoritm-dinamicheskoy-ierarhicheskoy-klasterizatsii-CHAMELEON.html</ref>.

'''Первый этап'''

На первом этапе, согласно графо-ориентированному подходу, происходит построение графа <math>G = (V, E)</math> на матрице сходства объектов по принципу k ближайших соседей. Две вершины такого графа соединяет ребро, если объект, соответствующий любой из этих вершин попадает в число k наиболее близких объектов для объекта, соответствующего другой вершине из данной пары.
[[Файл:Снимок chameleon 2.png|2000px|thumb|Рисунок 2. Объекты в пространстве - слева, граф по принципу 1-го ближайшего соседа - по центру, граф по принципу 3-х ближайших соседей - справа ]]

'''Второй этап'''

Алгоритм разделяет полученный граф на множество сравнительно малых подграфов <math>K= \{K_{i}\}</math>. Разделение происходит последовательно. На каждом шаге выбирается подграф, содержащий наибольшее число вершин. Этот граф разделяется на два подграфа так, что разделитель ребер графа минимален и каждый из получаемых подграфов содержит не менее 25 % вершин исходного графа. Процесс разделения останавливается, когда наибольший подграф содержит меньше некоторого заданного числа вершин. Обычно величина этого параметра задается равной значению от 1 до 5 % от числа объектов. Полученное множество связных графов считается множеством начальных кластеров, на котором требуется провести последовательное иерархическое объединение.

'''Третий этап'''

Третий этап заключается в итеративном преобразовании множества подграфов <math>K= \{K_{i}\}</math> в множество кластеров <math>C = \{C_{i}\}</math>. Алгоритм осуществляет агломеративную иерархическую кластеризацию на основании показателей <math>EC_{(C_{i},C_{j})}</math>, <math>S_{EC_{(C_{i},C_{j})}}</math>, <math>RI_{(C_{i},C_{j})} </math>, <math> RC_{(C_{i},C_{j})}</math>. Существует две стратегии анализа показателей сходства. Первая подразумевает наличие некоторых пороговых значений <math>T_{RI}</math> и <math>T_{RC}</math>. В соответствии с этой стратегией, алгоритм для каждого кластера <math>C_{i}</math> проверяет, отвечают ли смежные (наиболее близкие) ему кластеры условиям:

*<math>RI_{(C_{i},C_{j})} \geqslant T_{RI}</math>

*<math>RC_{(C_{i},C_{j})} \geqslant T_{RC}</math>

Если более одного смежного кластера отвечает этим условиям, то алгоритм выбирает для объединения наиболее связный кластер (граф), то есть такой кластер <math>C_{j}</math>, с которым у кластера <math>C_{i}</math> получается наибольшая абсолютная взаимная связность. По завершению прохода по всем кластерам, созданные таким образом пары объединяются. Параметры <math>T_{RI}</math> и <math>T_{RC}</math> могут использоваться для изменения характеристик получаемых кластеров.

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

<math>RI_{(C_{i},C_{j})}*RC_{(C_{i},C_{j})}^\alpha</math>,

где <math>\alpha</math> выбирается пользователем. Если <math>\alpha > 1 </math>, то алгоритм придает большее значение относительному взаимному сходству, а если <math>\alpha < 1 </math>, то большее значение имеет относительная взаимная связность.

''Вычисляемые данные'':

<math>U = (u_1, u_2, ..., u_n)</math> - n-мерный вектор, где <math>u_i \in N_{[C]}</math> - порядковый номер кластера, к которому принадлежит вершина i исходного множества V.

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

Алгоритм имеет три вычислительных ядра, по одному на каждый этап.

На первом этапе вычислительным ядром является процесс нахождения <math>k</math> ближайших соседей для каждой вершины, который заключается в анализе матрицы расстояний.

На втором этапе вычислительным ядром является процесс поиска подходящего разбиения очередного подграфа на два графа с минимизацией разделителя ребер графа.

На третьем этапе вычислительным ядром является расчет величин <math>EC_{(C_{i},C_{j})}</math>, <math>S_{EC_{(C_{i},C_{j})}}</math>, <math>RI_{(C_{i},C_{j})} </math>, <math> RC_{(C_{i},C_{j})}</math> для каждой пары смежных кластеров.

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

Как уже рассказывалось ранее, алгоритм включает в себя три основных этапа, каждый из которых, по сути, является отдельным алгоритмом. Этапы выполняются последовательно относительно друг друга.

Макрооперация на первом этапе - процедура нахождения <math>k</math> ближайших соседей, на втором - процедура разбиения наибольшего подграфа на два графа, на третьем - процедура вычисления показателей сходства, на основе которых принимается решение о слиянии подграфов в кластер.

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

'''Первый этап'''
<source lang="cpp">
int n; //количество вершин
int k; //количество соседей
int A[n][n] //матрица расстояний
int D[k] //массив вершин-соседей
int E[n][n] //матрица ребер графа <math>G_{2} = (K, E_{2})</math>
for i=1 to n-1 do
{
for j=i+1 to n do
{
//заполняем массив вершин-соседей вставляя новые вершины, если они ближе, чем самая далекая из массива.
}
for j=0 to k do
{
//для каждой вершины соседа заполняем соответствующую ячейку из матрицы E[n][n] единицей
}

}
</source>

'''Второй этап'''

1. Все связные подграфы в отсортированном порядке помещаются в список;
2. Берем наибольший элемент списка, вычисляем количество его вершин. Если число вершин > l, то идем в пункт 3. Иначе в пункт 5;
3. Разбиваем подграф на два подграфа таким образом, чтобы разделитель ребер графа был минимален и каждый из получаемых подграфов содержал не менее 25 % вершин исходного графа;
4. Добавляем полученные элементы в список подграфов таким образом, чтобы список оставался отсортированным. Идем в пункт 2;
5. Нашли искомое множество подграфов math>K = \{K_{i}\}</math>;
6. Создаем и заполняем матрицу матрицу расстояний для графа <math>G_{2} = (K, E_{2})</math>. Получаем искомый набор рёбер <math>E_{2}</math>.

'''Третий этап'''

1. Заводим два массива: а) массив кластеров C, полученных на предыдущем этапе, б) массив объединений кластеров F, которые мы будем получать на этом этапе;
2. Берем следующий кластер <math>C_{i}</math> (на первом шаге - первый). Если все кластеры просмотрены, идем в пункт 6;
3. Берем следующий кластер <math>C_{j}, i<>j</math>. Если все кластеры просмотрены, то идем в пункт 2;
4. Проверяем смежность <math>C_{i}</math> и <math>C_{j}</math>. Если не смежны, то возвращаемся в пункт 3. Если смежны, идем в пункт 5;
5. Рассчитываем показатели <math>RI_{(C_{i},C_{j})}</math> и <math> RC_{(C_{i},C_{j})}</math>. Проверяем, удовлетворяют ли найденные значения условиям:
*<math>RI_{(C_{i},C_{j})} \geqslant T_{RI}</math>
*<math>RC_{(C_{i},C_{j})} \geqslant T_{RC}</math>
Если нет, то идем в пункт 3. Иначе если смежность пары кластеров выше, чем у предыдущих найденных, то <math>F_{i}=j</math>. Идем в пункт 3;
6. Если в списке F есть хотя бы одна пара кластеров для слияния, то выполняем слияние, обновляем массив кластеров и массив объединений кластеров. Идем в пункт 2.

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

1) Для построения графа на основе метода k ближайших соседей для n вершин требуется <math>O(n log(n))</math> операций <ref>J.H. Friedman, J.L. Bentley, and R.A. Finkel. An algorithm for ﬁnding best matches in logarithmic expected time. ACM Transactions on Mathematical Software, 3:209–226, 1977.</ref>; для наборов данных большой размерности эта величина составляет <math>O(n^2)</math> операций <ref>S. Berchtold, C. Bohm, D. Keim, and H.-P. Kriegel. Cost model for nearest neighbor search in high dimensional data space. In Proc. of Symposium on Principles of Database Systems, Tucson, Arizona, 1997.</ref>;

2) Для выделения множества сравнительно малых связных подграфов требуется <math>nm</math> операций, где <math>m</math> - количество подграфов, полученных на втором этапе алгоритма;

3) Формирование набора кластеров, на основе множества подграфов, полученных на предыдущем этапе, требует <math>m^2log(m)</math> операций.

Итого, для n вершин получаем последовательную сложность <math>O(n log(n)+nm+m^2log(m))</math>.

== Информационный граф ==
[[File:СК.png]]

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

Первый этап работы алгоритма можно распределить между <math>n</math> процессами. На вход каждому процессу подается своя вершина, далее происходит процедура поиска <math>k</math> ближайших соседей. Параллельная сложность составляет <math>O(n)</math>.

Второй и третий этапы можно распараллелить частично.

Второй этап распараллеливается путем подачи на вход свободному процессу очередного подграфа для разделения. Число итераций оценивается в <math>O(n log(n))</math>.

Третий этап делится на расчет показателей схожести и соединение подграфов в кластеры. Процесс расчета показателей можно распараллелить, подавая каждому процессу на вход пару подграфов. Сложность этого процесса оценивается как <math>m log(m)</math>. Соединение подграфов в кластеры выполняется последовательно, сложность процесса составляет <math>m^2 log(m)</math>

Таким образом получаем общую параллельную сложность алгоритма: <math>O(n+ n log(n) + m^2 log (m) + m log(m))</math>

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

1. Симметрическая матрица <math>A</math> расстояний между элементами данных размера <math>n\times n</math> с нулями на главной диагонали (<math>a_{ii}= 0, i = 1, \ldots, N</math>).

2. <math>k</math> - количество ближайших соседей для вершин (рекомендуемое значение <math>k</math> от 5 до 20 в зависимости от количества анализируемых объектов).

3. <math>l</math> - наименьшее число вершин, которое может содержать наибольший подкластер на 2-м этапе . Величина этого параметра варьируется от 1 до 5 % от общего числа объектов.

'''Объём входных данных'''

<math>\frac{n (n - 1)}{2}</math> (в силу симметричности и нулевой главной диагонали достаточно хранить только над/поддиагональные элементы).

'''Выходные данные'''

Вектор из <math>n</math> чисел <math>u_{1}, u_{2}, \ldots, u_{N}</math>, где <math>u_{i}</math> - целое число, соответствующее кластеру <math>i</math>-го объекта.

'''Объём выходных данных'''

<math>n</math>

== Свойства алгоритма ==
Соотношение последовательной и параллельной сложности на первом этапе является ''линейным'' для больших наборов данных и логарифмическим для n вершин. На втором этапе сложно оценить это соотношение - оно сильно зависит от параметров <math>k</math> и <math>l</math>. На третьем этапе соотношение равно <math>O(1)</math>

Алгоритм является недетерминированным. Хотя 1-й этап детерминирован, на 2-ом этапе могут быть найдены различные разбиения на подграфы, что повлияет и на итоговый результат работы алгоритма.

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

см. позднее

== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Последовательная реализация алгоритма доступна по ссылке <ref>http://www.codeforge.com/article/192925</ref>.

CHAMELEON можно реализовать с использованием графовых библиотек METIS <ref>http://glaros.dtc.umn.edu/gkhome/metis/metis/overview
</ref>, hMETIS <ref>http://glaros.dtc.umn.edu/gkhome/metis/hmetis/overview</ref> и RANN <ref>https://cran.r-project.org/web/packages/RANN/index.html</ref>.

Существует исследование, связанное с реализацией CHAMELEON посредством технологии OpenMP, с которым можно ознакомиться здесь <ref>http://research.ijcaonline.org/volume79/number8/pxc3891600.pdf</ref>.

Параллельных реализаций алгоритма CHAMELEON не найдено.

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

[3] J.H. Friedman, J.L. Bentley, and R.A. Finkel. An algorithm for ﬁnding best matches in logarithmic expected time. ACM Transactions on Mathematical Software, 3:209–226, 1977.

[4] S. Berchtold, C. Bohm, D. Keim, and H.-P. Kriegel. Cost model for nearest neighbor search in high dimensional data space. In Proc. of Symposium on Principles of Database Systems, Tucson, Arizona, 1997.

Участник:ЕкатеринаКозырева/Алгоритм динамической иерархической кластеризации CHAMELEON

2016-10-31T18:55:40Z

ЕкатеринаКозырева: /* Литература */

{{algorithm
| name = Алгоритм динамической иерархической кластеризации CHAMELEON
| serial_complexity = <math>O(nm + n log n + m^2 log m)</math>
| input_data = <math>\frac{n (n - 1)}{2}</math>
| output_data = <math>n</math>
| pf_height = <math>O(n+ n log(n) + m^2 log (m) + m log(m))</math>
| pf_width = <math>O(n)</math>
}}

Автор описания [[Участник:ЕкатеринаКозырева|Е.А.Козырева]]
= Свойства и структура алгоритмов =

== Общее описание алгоритма ==
Алгоритм CHAMELEON был предложен в 1999 году тремя учеными из университета Миннесоты – George Karypis, Eui-Hong (Sam) Han и Vipin Kumar<ref>George Karypis, Eui-Hong (Sam) Han и Vipin Kumar, «Chameleon: Hierarchical Clustering Using Dynamic Modeling», 1999.</ref>.

Предназначен для решения задач кластеризации. Кластеризация (или кластерный анализ) — это задача разбиения множества объектов на группы, называемые кластерами. Внутри каждой группы должны оказаться «похожие» объекты, а объекты разных группы должны быть как можно более отличны.

CHAMELEON - это агломеративный иерархический алгоритм кластеризации, ключевой особенностью которого является то, что он учитывает и взаимную связность, и сходство при определении наиболее похожей пары подкластеров, основываясь на динамической модели. Это означает, что в процессе кластеризации два кластера объединяются, только если их относительная взаимная связность и относительное взаимное сходство являются высокими по отношению к внутренней взаимосвязанности кластеров и близости элементов внутри кластеров. Кроме того, CHAMELEON использует подход для моделирования степени взаимосвязанности и близости между каждой парой кластеров, который учитывает внутренние характеристики самих кластеров. Таким образом, он может автоматически адаптироваться к внутренним характеристикам объединяемых кластеров.

CHAMELEON находит кластеры в наборе данных с помощью трехфазного алгоритма. На первой фазе происходит построение графа, путём добавления рёбер по принципу k ближайших соседей. На второй фазе CHAMELEON группирует полученные элементы в множество относительно небольших подграфов. Во время третьей фазы применяется агломеративный иерархический алгоритм кластеризации, с помощью которого находятся естесственные кластеры путем многократного объединения подграфов, полученных на прошлом этапе.

[[File:Chameleon.png|1000px|thumb|center|Рисунок 1. Общая структура алгоритма CHAMELEON]]

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

''Исходные данные'':

* Множество из n точек <math>V= {v_{ij}}</math> в метрическом пространстве, которое задано симметрической матрицей расстояний <math>A</math> размера <math>n\times n</math>.
* <math>k</math> - количество ближайших соседей для вершин, <math>k \in N, k \leq n</math>.
* <math>l</math> - наименьшее число вершин, которое может содержать наибольший подграф на 2-м этапе, <math>l \in N, l \leq n</math>.

''Обозначения'':

* <math>G = (V, E)</math> - граф, полученный путём соединения каждой точки с её <math>k</math> ближайшими соседями.

* <math>K= \{K_{i}\}</math> - разбиение множества <math>V</math> на набор попарно непересекающихся связных подмножеств, полученное в результате выполнения второй фазы алгоритма.

* <math>G_{2} = (K, E_{2})</math> - взвешенный граф, вершинами которого являются получившиеся подграфы, а ребрами - количество ребер исходного графа, соединяющих соответствующие подграфы.

* <math>C = \{C_{i}\}</math> - итоговое разбиение множества вершин графа <math>G_{2}</math> на набор кластеров.

''Вспомогательные понятия''

*<math>EC_{(C_{i},C_{j})}</math> - абсолютная взаимная связность пары кластеров <math>C_{i}, C{j}</math>. Определяется как сумма весов ребер, соединяющих вершины, принадлежащие <math>C{i}</math> c вершинами из <math>C{j}</math>. Внутренняя связность <math>EC_{(C_{i},C_{i})}</math> вычисляется как сумма ребер, входящих в разделитель, разбивающий <math>C{i}</math> на два равных подграфа.

*<math>RI_{(C_{i},C_{j})} = \frac{|EC_{(C_{i},C_{j})}|}{(|EC_{C_{i}}|+|EC_{C_{j}}|)/2}</math> - относительная взаимная связность пары кластеров <math>C_{i}, C{j}</math>

*<math>S_{EC_{(C_{i},C_{j})}}</math> - абсолютное взаимное сходство пары кластеров <math>C_{i}, C{j}</math>. Подсчитывается как среднее сходство между соединенными вершинами, принадлежащими <math>C{i}</math> и <math>C{j}</math> соответственно. Соединения обусловлены разбиением общего графа, полученного на первом этапе алгоритма.

*<math> RC_{(C_{i},C_{j})}= \frac{S_{EC_{(C_{i},C_{j})}}}{\frac{|C_{i}|}{|C_{i}+C_{j}|}*S_{EC_{(C_{i})}}+\frac{|C_{i}|}{|C_{i}+C_{j}|}*S_{EC_{(C_{j})}}}</math> - относительное взаимное сходство пары кластеров <math>C_{i}, C{j}</math>. Определяется как абсолютное сходство между этой парой кластеров, нормализованное с учетом их внутреннего сходства<ref>http://studopedia.ru/7_41934_algoritm-dinamicheskoy-ierarhicheskoy-klasterizatsii-CHAMELEON.html</ref>.

'''Первый этап'''

На первом этапе, согласно графо-ориентированному подходу, происходит построение графа <math>G = (V, E)</math> на матрице сходства объектов по принципу k ближайших соседей. Две вершины такого графа соединяет ребро, если объект, соответствующий любой из этих вершин попадает в число k наиболее близких объектов для объекта, соответствующего другой вершине из данной пары.
[[Файл:Снимок chameleon 2.png|2000px|thumb|Рисунок 2. Объекты в пространстве - слева, граф по принципу 1-го ближайшего соседа - по центру, граф по принципу 3-х ближайших соседей - справа ]]

'''Второй этап'''

Алгоритм разделяет полученный граф на множество сравнительно малых подграфов <math>K= \{K_{i}\}</math>. Разделение происходит последовательно. На каждом шаге выбирается подграф, содержащий наибольшее число вершин. Этот граф разделяется на два подграфа так, что разделитель ребер графа минимален и каждый из получаемых подграфов содержит не менее 25 % вершин исходного графа. Процесс разделения останавливается, когда наибольший подграф содержит меньше некоторого заданного числа вершин. Обычно величина этого параметра задается равной значению от 1 до 5 % от числа объектов. Полученное множество связных графов считается множеством начальных кластеров, на котором требуется провести последовательное иерархическое объединение.

'''Третий этап'''

Третий этап заключается в итеративном преобразовании множества подграфов <math>K= \{K_{i}\}</math> в множество кластеров <math>C = \{C_{i}\}</math>. Алгоритм осуществляет агломеративную иерархическую кластеризацию на основании показателей <math>EC_{(C_{i},C_{j})}</math>, <math>S_{EC_{(C_{i},C_{j})}}</math>, <math>RI_{(C_{i},C_{j})} </math>, <math> RC_{(C_{i},C_{j})}</math>. Существует две стратегии анализа показателей сходства. Первая подразумевает наличие некоторых пороговых значений <math>T_{RI}</math> и <math>T_{RC}</math>. В соответствии с этой стратегией, алгоритм для каждого кластера <math>C_{i}</math> проверяет, отвечают ли смежные (наиболее близкие) ему кластеры условиям:

*<math>RI_{(C_{i},C_{j})} \geqslant T_{RI}</math>

*<math>RC_{(C_{i},C_{j})} \geqslant T_{RC}</math>

Если более одного смежного кластера отвечает этим условиям, то алгоритм выбирает для объединения наиболее связный кластер (граф), то есть такой кластер <math>C_{j}</math>, с которым у кластера <math>C_{i}</math> получается наибольшая абсолютная взаимная связность. По завершению прохода по всем кластерам, созданные таким образом пары объединяются. Параметры <math>T_{RI}</math> и <math>T_{RC}</math> могут использоваться для изменения характеристик получаемых кластеров.

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

<math>RI_{(C_{i},C_{j})}*RC_{(C_{i},C_{j})}^\alpha</math>,

где <math>\alpha</math> выбирается пользователем. Если <math>\alpha > 1 </math>, то алгоритм придает большее значение относительному взаимному сходству, а если <math>\alpha < 1 </math>, то большее значение имеет относительная взаимная связность.

''Вычисляемые данные'':

<math>U = (u_1, u_2, ..., u_n)</math> - n-мерный вектор, где <math>u_i \in N_{[C]}</math> - порядковый номер кластера, к которому принадлежит вершина i исходного множества V.

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

Алгоритм имеет три вычислительных ядра, по одному на каждый этап.

На первом этапе вычислительным ядром является процесс нахождения <math>k</math> ближайших соседей для каждой вершины, который заключается в анализе матрицы расстояний.

На втором этапе вычислительным ядром является процесс поиска подходящего разбиения очередного подграфа на два графа с минимизацией разделителя ребер графа.

На третьем этапе вычислительным ядром является расчет величин <math>EC_{(C_{i},C_{j})}</math>, <math>S_{EC_{(C_{i},C_{j})}}</math>, <math>RI_{(C_{i},C_{j})} </math>, <math> RC_{(C_{i},C_{j})}</math> для каждой пары смежных кластеров.

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

Как уже рассказывалось ранее, алгоритм включает в себя три основных этапа, каждый из которых, по сути, является отдельным алгоритмом. Этапы выполняются последовательно относительно друг друга.

Макрооперация на первом этапе - процедура нахождения <math>k</math> ближайших соседей, на втором - процедура разбиения наибольшего подграфа на два графа, на третьем - процедура вычисления показателей сходства, на основе которых принимается решение о слиянии подграфов в кластер.

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

'''Первый этап'''
<source lang="cpp">
int n; //количество вершин
int k; //количество соседей
int A[n][n] //матрица расстояний
int D[k] //массив вершин-соседей
int E[n][n] //матрица ребер графа <math>G_{2} = (K, E_{2})</math>
for i=1 to n-1 do
{
for j=i+1 to n do
{
//заполняем массив вершин-соседей вставляя новые вершины, если они ближе, чем самая далекая из массива.
}
for j=0 to k do
{
//для каждой вершины соседа заполняем соответствующую ячейку из матрицы E[n][n] единицей
}

}
</source>

'''Второй этап'''

1. Все связные подграфы в отсортированном порядке помещаются в список;
2. Берем наибольший элемент списка, вычисляем количество его вершин. Если число вершин > l, то идем в пункт 3. Иначе в пункт 5;
3. Разбиваем подграф на два подграфа таким образом, чтобы разделитель ребер графа был минимален и каждый из получаемых подграфов содержал не менее 25 % вершин исходного графа;
4. Добавляем полученные элементы в список подграфов таким образом, чтобы список оставался отсортированным. Идем в пункт 2;
5. Нашли искомое множество подграфов math>K = \{K_{i}\}</math>;
6. Создаем и заполняем матрицу матрицу расстояний для графа <math>G_{2} = (K, E_{2})</math>. Получаем искомый набор рёбер <math>E_{2}</math>.

'''Третий этап'''

1. Заводим два массива: а) массив кластеров C, полученных на предыдущем этапе, б) массив объединений кластеров F, которые мы будем получать на этом этапе;
2. Берем следующий кластер <math>C_{i}</math> (на первом шаге - первый). Если все кластеры просмотрены, идем в пункт 6;
3. Берем следующий кластер <math>C_{j}, i<>j</math>. Если все кластеры просмотрены, то идем в пункт 2;
4. Проверяем смежность <math>C_{i}</math> и <math>C_{j}</math>. Если не смежны, то возвращаемся в пункт 3. Если смежны, идем в пункт 5;
5. Рассчитываем показатели <math>RI_{(C_{i},C_{j})}</math> и <math> RC_{(C_{i},C_{j})}</math>. Проверяем, удовлетворяют ли найденные значения условиям:
*<math>RI_{(C_{i},C_{j})} \geqslant T_{RI}</math>
*<math>RC_{(C_{i},C_{j})} \geqslant T_{RC}</math>
Если нет, то идем в пункт 3. Иначе если смежность пары кластеров выше, чем у предыдущих найденных, то <math>F_{i}=j</math>. Идем в пункт 3;
6. Если в списке F есть хотя бы одна пара кластеров для слияния, то выполняем слияние, обновляем массив кластеров и массив объединений кластеров. Идем в пункт 2.

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

1) Для построения графа на основе метода k ближайших соседей для n вершин требуется <math>O(n log(n))</math> операций [3]; для наборов данных большой размерности эта величина составляет <math>O(n^2)</math> операций [4];

2) Для выделения множества сравнительно малых связных подграфов требуется <math>nm</math> операций, где <math>m</math> - количество подграфов, полученных на втором этапе алгоритма;

3) Формирование набора кластеров, на основе множества подграфов, полученных на предыдущем этапе, требует <math>m^2log(m)</math> операций.

Итого, для n вершин получаем последовательную сложность <math>O(n log(n)+nm+m^2log(m))</math>.

== Информационный граф ==
[[File:СК.png]]

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

Первый этап работы алгоритма можно распределить между <math>n</math> процессами. На вход каждому процессу подается своя вершина, далее происходит процедура поиска <math>k</math> ближайших соседей. Параллельная сложность составляет <math>O(n)</math>.

Второй и третий этапы можно распараллелить частично.

Второй этап распараллеливается путем подачи на вход свободному процессу очередного подграфа для разделения. Число итераций оценивается в <math>O(n log(n))</math>.

Третий этап делится на расчет показателей схожести и соединение подграфов в кластеры. Процесс расчета показателей можно распараллелить, подавая каждому процессу на вход пару подграфов. Сложность этого процесса оценивается как <math>m log(m)</math>. Соединение подграфов в кластеры выполняется последовательно, сложность процесса составляет <math>m^2 log(m)</math>

Таким образом получаем общую параллельную сложность алгоритма: <math>O(n+ n log(n) + m^2 log (m) + m log(m))</math>

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

1. Симметрическая матрица <math>A</math> расстояний между элементами данных размера <math>n\times n</math> с нулями на главной диагонали (<math>a_{ii}= 0, i = 1, \ldots, N</math>).

2. <math>k</math> - количество ближайших соседей для вершин (рекомендуемое значение <math>k</math> от 5 до 20 в зависимости от количества анализируемых объектов).

3. <math>l</math> - наименьшее число вершин, которое может содержать наибольший подкластер на 2-м этапе . Величина этого параметра варьируется от 1 до 5 % от общего числа объектов.

'''Объём входных данных'''

<math>\frac{n (n - 1)}{2}</math> (в силу симметричности и нулевой главной диагонали достаточно хранить только над/поддиагональные элементы).

'''Выходные данные'''

Вектор из <math>n</math> чисел <math>u_{1}, u_{2}, \ldots, u_{N}</math>, где <math>u_{i}</math> - целое число, соответствующее кластеру <math>i</math>-го объекта.

'''Объём выходных данных'''

<math>n</math>

== Свойства алгоритма ==
Соотношение последовательной и параллельной сложности на первом этапе является ''линейным'' для больших наборов данных и логарифмическим для n вершин. На втором этапе сложно оценить это соотношение - оно сильно зависит от параметров <math>k</math> и <math>l</math>. На третьем этапе соотношение равно <math>O(1)</math>

Алгоритм является недетерминированным. Хотя 1-й этап детерминирован, на 2-ом этапе могут быть найдены различные разбиения на подграфы, что повлияет и на итоговый результат работы алгоритма.

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

см. позднее

== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Последовательная реализация алгоритма доступна по ссылке <ref>http://www.codeforge.com/article/192925</ref>.

CHAMELEON можно реализовать с использованием графовых библиотек METIS <ref>http://glaros.dtc.umn.edu/gkhome/metis/metis/overview
</ref>, hMETIS <ref>http://glaros.dtc.umn.edu/gkhome/metis/hmetis/overview</ref> и RANN <ref>https://cran.r-project.org/web/packages/RANN/index.html</ref>.

Существует исследование, связанное с реализацией CHAMELEON посредством технологии OpenMP, с которым можно ознакомиться здесь <ref>http://research.ijcaonline.org/volume79/number8/pxc3891600.pdf</ref>.

Параллельных реализаций алгоритма CHAMELEON не найдено.

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

[3] J.H. Friedman, J.L. Bentley, and R.A. Finkel. An algorithm for ﬁnding best matches in logarithmic expected time. ACM Transactions on Mathematical Software, 3:209–226, 1977.

[4] S. Berchtold, C. Bohm, D. Keim, and H.-P. Kriegel. Cost model for nearest neighbor search in high dimensional data space. In Proc. of Symposium on Principles of Database Systems, Tucson, Arizona, 1997.

Участник:ЕкатеринаКозырева/Алгоритм динамической иерархической кластеризации CHAMELEON

2016-10-31T18:51:55Z

ЕкатеринаКозырева: /* Математическое описание алгоритма */

{{algorithm
| name = Алгоритм динамической иерархической кластеризации CHAMELEON
| serial_complexity = <math>O(nm + n log n + m^2 log m)</math>
| input_data = <math>\frac{n (n - 1)}{2}</math>
| output_data = <math>n</math>
| pf_height = <math>O(n+ n log(n) + m^2 log (m) + m log(m))</math>
| pf_width = <math>O(n)</math>
}}

Автор описания [[Участник:ЕкатеринаКозырева|Е.А.Козырева]]
= Свойства и структура алгоритмов =

== Общее описание алгоритма ==
Алгоритм CHAMELEON был предложен в 1999 году тремя учеными из университета Миннесоты – George Karypis, Eui-Hong (Sam) Han и Vipin Kumar<ref>George Karypis, Eui-Hong (Sam) Han и Vipin Kumar, «Chameleon: Hierarchical Clustering Using Dynamic Modeling», 1999.</ref>.

Предназначен для решения задач кластеризации. Кластеризация (или кластерный анализ) — это задача разбиения множества объектов на группы, называемые кластерами. Внутри каждой группы должны оказаться «похожие» объекты, а объекты разных группы должны быть как можно более отличны.

CHAMELEON - это агломеративный иерархический алгоритм кластеризации, ключевой особенностью которого является то, что он учитывает и взаимную связность, и сходство при определении наиболее похожей пары подкластеров, основываясь на динамической модели. Это означает, что в процессе кластеризации два кластера объединяются, только если их относительная взаимная связность и относительное взаимное сходство являются высокими по отношению к внутренней взаимосвязанности кластеров и близости элементов внутри кластеров. Кроме того, CHAMELEON использует подход для моделирования степени взаимосвязанности и близости между каждой парой кластеров, который учитывает внутренние характеристики самих кластеров. Таким образом, он может автоматически адаптироваться к внутренним характеристикам объединяемых кластеров.

CHAMELEON находит кластеры в наборе данных с помощью трехфазного алгоритма. На первой фазе происходит построение графа, путём добавления рёбер по принципу k ближайших соседей. На второй фазе CHAMELEON группирует полученные элементы в множество относительно небольших подграфов. Во время третьей фазы применяется агломеративный иерархический алгоритм кластеризации, с помощью которого находятся естесственные кластеры путем многократного объединения подграфов, полученных на прошлом этапе.

[[File:Chameleon.png|1000px|thumb|center|Рисунок 1. Общая структура алгоритма CHAMELEON]]

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

''Исходные данные'':

* Множество из n точек <math>V= {v_{ij}}</math> в метрическом пространстве, которое задано симметрической матрицей расстояний <math>A</math> размера <math>n\times n</math>.
* <math>k</math> - количество ближайших соседей для вершин, <math>k \in N, k \leq n</math>.
* <math>l</math> - наименьшее число вершин, которое может содержать наибольший подграф на 2-м этапе, <math>l \in N, l \leq n</math>.

''Обозначения'':

* <math>G = (V, E)</math> - граф, полученный путём соединения каждой точки с её <math>k</math> ближайшими соседями.

* <math>K= \{K_{i}\}</math> - разбиение множества <math>V</math> на набор попарно непересекающихся связных подмножеств, полученное в результате выполнения второй фазы алгоритма.

* <math>G_{2} = (K, E_{2})</math> - взвешенный граф, вершинами которого являются получившиеся подграфы, а ребрами - количество ребер исходного графа, соединяющих соответствующие подграфы.

* <math>C = \{C_{i}\}</math> - итоговое разбиение множества вершин графа <math>G_{2}</math> на набор кластеров.

''Вспомогательные понятия''

*<math>EC_{(C_{i},C_{j})}</math> - абсолютная взаимная связность пары кластеров <math>C_{i}, C{j}</math>. Определяется как сумма весов ребер, соединяющих вершины, принадлежащие <math>C{i}</math> c вершинами из <math>C{j}</math>. Внутренняя связность <math>EC_{(C_{i},C_{i})}</math> вычисляется как сумма ребер, входящих в разделитель, разбивающий <math>C{i}</math> на два равных подграфа.

*<math>RI_{(C_{i},C_{j})} = \frac{|EC_{(C_{i},C_{j})}|}{(|EC_{C_{i}}|+|EC_{C_{j}}|)/2}</math> - относительная взаимная связность пары кластеров <math>C_{i}, C{j}</math>

*<math>S_{EC_{(C_{i},C_{j})}}</math> - абсолютное взаимное сходство пары кластеров <math>C_{i}, C{j}</math>. Подсчитывается как среднее сходство между соединенными вершинами, принадлежащими <math>C{i}</math> и <math>C{j}</math> соответственно. Соединения обусловлены разбиением общего графа, полученного на первом этапе алгоритма.

*<math> RC_{(C_{i},C_{j})}= \frac{S_{EC_{(C_{i},C_{j})}}}{\frac{|C_{i}|}{|C_{i}+C_{j}|}*S_{EC_{(C_{i})}}+\frac{|C_{i}|}{|C_{i}+C_{j}|}*S_{EC_{(C_{j})}}}</math> - относительное взаимное сходство пары кластеров <math>C_{i}, C{j}</math>. Определяется как абсолютное сходство между этой парой кластеров, нормализованное с учетом их внутреннего сходства<ref>http://studopedia.ru/7_41934_algoritm-dinamicheskoy-ierarhicheskoy-klasterizatsii-CHAMELEON.html</ref>.

'''Первый этап'''

На первом этапе, согласно графо-ориентированному подходу, происходит построение графа <math>G = (V, E)</math> на матрице сходства объектов по принципу k ближайших соседей. Две вершины такого графа соединяет ребро, если объект, соответствующий любой из этих вершин попадает в число k наиболее близких объектов для объекта, соответствующего другой вершине из данной пары.
[[Файл:Снимок chameleon 2.png|2000px|thumb|Рисунок 2. Объекты в пространстве - слева, граф по принципу 1-го ближайшего соседа - по центру, граф по принципу 3-х ближайших соседей - справа ]]

'''Второй этап'''

Алгоритм разделяет полученный граф на множество сравнительно малых подграфов <math>K= \{K_{i}\}</math>. Разделение происходит последовательно. На каждом шаге выбирается подграф, содержащий наибольшее число вершин. Этот граф разделяется на два подграфа так, что разделитель ребер графа минимален и каждый из получаемых подграфов содержит не менее 25 % вершин исходного графа. Процесс разделения останавливается, когда наибольший подграф содержит меньше некоторого заданного числа вершин. Обычно величина этого параметра задается равной значению от 1 до 5 % от числа объектов. Полученное множество связных графов считается множеством начальных кластеров, на котором требуется провести последовательное иерархическое объединение.

'''Третий этап'''

Третий этап заключается в итеративном преобразовании множества подграфов <math>K= \{K_{i}\}</math> в множество кластеров <math>C = \{C_{i}\}</math>. Алгоритм осуществляет агломеративную иерархическую кластеризацию на основании показателей <math>EC_{(C_{i},C_{j})}</math>, <math>S_{EC_{(C_{i},C_{j})}}</math>, <math>RI_{(C_{i},C_{j})} </math>, <math> RC_{(C_{i},C_{j})}</math>. Существует две стратегии анализа показателей сходства. Первая подразумевает наличие некоторых пороговых значений <math>T_{RI}</math> и <math>T_{RC}</math>. В соответствии с этой стратегией, алгоритм для каждого кластера <math>C_{i}</math> проверяет, отвечают ли смежные (наиболее близкие) ему кластеры условиям:

*<math>RI_{(C_{i},C_{j})} \geqslant T_{RI}</math>

*<math>RC_{(C_{i},C_{j})} \geqslant T_{RC}</math>

Если более одного смежного кластера отвечает этим условиям, то алгоритм выбирает для объединения наиболее связный кластер (граф), то есть такой кластер <math>C_{j}</math>, с которым у кластера <math>C_{i}</math> получается наибольшая абсолютная взаимная связность. По завершению прохода по всем кластерам, созданные таким образом пары объединяются. Параметры <math>T_{RI}</math> и <math>T_{RC}</math> могут использоваться для изменения характеристик получаемых кластеров.

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

<math>RI_{(C_{i},C_{j})}*RC_{(C_{i},C_{j})}^\alpha</math>,

где <math>\alpha</math> выбирается пользователем. Если <math>\alpha > 1 </math>, то алгоритм придает большее значение относительному взаимному сходству, а если <math>\alpha < 1 </math>, то большее значение имеет относительная взаимная связность.

''Вычисляемые данные'':

<math>U = (u_1, u_2, ..., u_n)</math> - n-мерный вектор, где <math>u_i \in N_{[C]}</math> - порядковый номер кластера, к которому принадлежит вершина i исходного множества V.

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

Алгоритм имеет три вычислительных ядра, по одному на каждый этап.

На первом этапе вычислительным ядром является процесс нахождения <math>k</math> ближайших соседей для каждой вершины, который заключается в анализе матрицы расстояний.

На втором этапе вычислительным ядром является процесс поиска подходящего разбиения очередного подграфа на два графа с минимизацией разделителя ребер графа.

На третьем этапе вычислительным ядром является расчет величин <math>EC_{(C_{i},C_{j})}</math>, <math>S_{EC_{(C_{i},C_{j})}}</math>, <math>RI_{(C_{i},C_{j})} </math>, <math> RC_{(C_{i},C_{j})}</math> для каждой пары смежных кластеров.

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

Как уже рассказывалось ранее, алгоритм включает в себя три основных этапа, каждый из которых, по сути, является отдельным алгоритмом. Этапы выполняются последовательно относительно друг друга.

Макрооперация на первом этапе - процедура нахождения <math>k</math> ближайших соседей, на втором - процедура разбиения наибольшего подграфа на два графа, на третьем - процедура вычисления показателей сходства, на основе которых принимается решение о слиянии подграфов в кластер.

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

'''Первый этап'''
<source lang="cpp">
int n; //количество вершин
int k; //количество соседей
int A[n][n] //матрица расстояний
int D[k] //массив вершин-соседей
int E[n][n] //матрица ребер графа <math>G_{2} = (K, E_{2})</math>
for i=1 to n-1 do
{
for j=i+1 to n do
{
//заполняем массив вершин-соседей вставляя новые вершины, если они ближе, чем самая далекая из массива.
}
for j=0 to k do
{
//для каждой вершины соседа заполняем соответствующую ячейку из матрицы E[n][n] единицей
}

}
</source>

'''Второй этап'''

1. Все связные подграфы в отсортированном порядке помещаются в список;
2. Берем наибольший элемент списка, вычисляем количество его вершин. Если число вершин > l, то идем в пункт 3. Иначе в пункт 5;
3. Разбиваем подграф на два подграфа таким образом, чтобы разделитель ребер графа был минимален и каждый из получаемых подграфов содержал не менее 25 % вершин исходного графа;
4. Добавляем полученные элементы в список подграфов таким образом, чтобы список оставался отсортированным. Идем в пункт 2;
5. Нашли искомое множество подграфов math>K = \{K_{i}\}</math>;
6. Создаем и заполняем матрицу матрицу расстояний для графа <math>G_{2} = (K, E_{2})</math>. Получаем искомый набор рёбер <math>E_{2}</math>.

'''Третий этап'''

1. Заводим два массива: а) массив кластеров C, полученных на предыдущем этапе, б) массив объединений кластеров F, которые мы будем получать на этом этапе;
2. Берем следующий кластер <math>C_{i}</math> (на первом шаге - первый). Если все кластеры просмотрены, идем в пункт 6;
3. Берем следующий кластер <math>C_{j}, i<>j</math>. Если все кластеры просмотрены, то идем в пункт 2;
4. Проверяем смежность <math>C_{i}</math> и <math>C_{j}</math>. Если не смежны, то возвращаемся в пункт 3. Если смежны, идем в пункт 5;
5. Рассчитываем показатели <math>RI_{(C_{i},C_{j})}</math> и <math> RC_{(C_{i},C_{j})}</math>. Проверяем, удовлетворяют ли найденные значения условиям:
*<math>RI_{(C_{i},C_{j})} \geqslant T_{RI}</math>
*<math>RC_{(C_{i},C_{j})} \geqslant T_{RC}</math>
Если нет, то идем в пункт 3. Иначе если смежность пары кластеров выше, чем у предыдущих найденных, то <math>F_{i}=j</math>. Идем в пункт 3;
6. Если в списке F есть хотя бы одна пара кластеров для слияния, то выполняем слияние, обновляем массив кластеров и массив объединений кластеров. Идем в пункт 2.

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

1) Для построения графа на основе метода k ближайших соседей для n вершин требуется <math>O(n log(n))</math> операций [3]; для наборов данных большой размерности эта величина составляет <math>O(n^2)</math> операций [4];

2) Для выделения множества сравнительно малых связных подграфов требуется <math>nm</math> операций, где <math>m</math> - количество подграфов, полученных на втором этапе алгоритма;

3) Формирование набора кластеров, на основе множества подграфов, полученных на предыдущем этапе, требует <math>m^2log(m)</math> операций.

Итого, для n вершин получаем последовательную сложность <math>O(n log(n)+nm+m^2log(m))</math>.

== Информационный граф ==
[[File:СК.png]]

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

Первый этап работы алгоритма можно распределить между <math>n</math> процессами. На вход каждому процессу подается своя вершина, далее происходит процедура поиска <math>k</math> ближайших соседей. Параллельная сложность составляет <math>O(n)</math>.

Второй и третий этапы можно распараллелить частично.

Второй этап распараллеливается путем подачи на вход свободному процессу очередного подграфа для разделения. Число итераций оценивается в <math>O(n log(n))</math>.

Третий этап делится на расчет показателей схожести и соединение подграфов в кластеры. Процесс расчета показателей можно распараллелить, подавая каждому процессу на вход пару подграфов. Сложность этого процесса оценивается как <math>m log(m)</math>. Соединение подграфов в кластеры выполняется последовательно, сложность процесса составляет <math>m^2 log(m)</math>

Таким образом получаем общую параллельную сложность алгоритма: <math>O(n+ n log(n) + m^2 log (m) + m log(m))</math>

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

1. Симметрическая матрица <math>A</math> расстояний между элементами данных размера <math>n\times n</math> с нулями на главной диагонали (<math>a_{ii}= 0, i = 1, \ldots, N</math>).

2. <math>k</math> - количество ближайших соседей для вершин (рекомендуемое значение <math>k</math> от 5 до 20 в зависимости от количества анализируемых объектов).

3. <math>l</math> - наименьшее число вершин, которое может содержать наибольший подкластер на 2-м этапе . Величина этого параметра варьируется от 1 до 5 % от общего числа объектов.

'''Объём входных данных'''

<math>\frac{n (n - 1)}{2}</math> (в силу симметричности и нулевой главной диагонали достаточно хранить только над/поддиагональные элементы).

'''Выходные данные'''

Вектор из <math>n</math> чисел <math>u_{1}, u_{2}, \ldots, u_{N}</math>, где <math>u_{i}</math> - целое число, соответствующее кластеру <math>i</math>-го объекта.

'''Объём выходных данных'''

<math>n</math>

== Свойства алгоритма ==
Соотношение последовательной и параллельной сложности на первом этапе является ''линейным'' для больших наборов данных и логарифмическим для n вершин. На втором этапе сложно оценить это соотношение - оно сильно зависит от параметров <math>k</math> и <math>l</math>. На третьем этапе соотношение равно <math>O(1)</math>

Алгоритм является недетерминированным. Хотя 1-й этап детерминирован, на 2-ом этапе могут быть найдены различные разбиения на подграфы, что повлияет и на итоговый результат работы алгоритма.

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

см. позднее

== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Последовательная реализация алгоритма доступна по ссылке <ref>http://www.codeforge.com/article/192925</ref>.

CHAMELEON можно реализовать с использованием графовых библиотек METIS <ref>http://glaros.dtc.umn.edu/gkhome/metis/metis/overview
</ref>, hMETIS <ref>http://glaros.dtc.umn.edu/gkhome/metis/hmetis/overview</ref> и RANN <ref>https://cran.r-project.org/web/packages/RANN/index.html</ref>.

Существует исследование, связанное с реализацией CHAMELEON посредством технологии OpenMP, с которым можно ознакомиться здесь <ref>http://research.ijcaonline.org/volume79/number8/pxc3891600.pdf</ref>.

Параллельных реализаций алгоритма CHAMELEON не найдено.

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

[2] http://studopedia.ru/7_41934_algoritm-dinamicheskoy-ierarhicheskoy-klasterizatsii-CHAMELEON.html

[3] J.H. Friedman, J.L. Bentley, and R.A. Finkel. An algorithm for ﬁnding best matches in logarithmic expected time. ACM Transactions on Mathematical Software, 3:209–226, 1977.

[4] S. Berchtold, C. Bohm, D. Keim, and H.-P. Kriegel. Cost model for nearest neighbor search in high dimensional data space. In Proc. of Symposium on Principles of Database Systems, Tucson, Arizona, 1997.

Участник:ЕкатеринаКозырева/Алгоритм динамической иерархической кластеризации CHAMELEON

2016-10-31T18:51:15Z

ЕкатеринаКозырева: /* Математическое описание алгоритма */

{{algorithm
| name = Алгоритм динамической иерархической кластеризации CHAMELEON
| serial_complexity = <math>O(nm + n log n + m^2 log m)</math>
| input_data = <math>\frac{n (n - 1)}{2}</math>
| output_data = <math>n</math>
| pf_height = <math>O(n+ n log(n) + m^2 log (m) + m log(m))</math>
| pf_width = <math>O(n)</math>
}}

Автор описания [[Участник:ЕкатеринаКозырева|Е.А.Козырева]]
= Свойства и структура алгоритмов =

== Общее описание алгоритма ==
Алгоритм CHAMELEON был предложен в 1999 году тремя учеными из университета Миннесоты – George Karypis, Eui-Hong (Sam) Han и Vipin Kumar<ref>George Karypis, Eui-Hong (Sam) Han и Vipin Kumar, «Chameleon: Hierarchical Clustering Using Dynamic Modeling», 1999.</ref>.

Предназначен для решения задач кластеризации. Кластеризация (или кластерный анализ) — это задача разбиения множества объектов на группы, называемые кластерами. Внутри каждой группы должны оказаться «похожие» объекты, а объекты разных группы должны быть как можно более отличны.

CHAMELEON - это агломеративный иерархический алгоритм кластеризации, ключевой особенностью которого является то, что он учитывает и взаимную связность, и сходство при определении наиболее похожей пары подкластеров, основываясь на динамической модели. Это означает, что в процессе кластеризации два кластера объединяются, только если их относительная взаимная связность и относительное взаимное сходство являются высокими по отношению к внутренней взаимосвязанности кластеров и близости элементов внутри кластеров. Кроме того, CHAMELEON использует подход для моделирования степени взаимосвязанности и близости между каждой парой кластеров, который учитывает внутренние характеристики самих кластеров. Таким образом, он может автоматически адаптироваться к внутренним характеристикам объединяемых кластеров.

CHAMELEON находит кластеры в наборе данных с помощью трехфазного алгоритма. На первой фазе происходит построение графа, путём добавления рёбер по принципу k ближайших соседей. На второй фазе CHAMELEON группирует полученные элементы в множество относительно небольших подграфов. Во время третьей фазы применяется агломеративный иерархический алгоритм кластеризации, с помощью которого находятся естесственные кластеры путем многократного объединения подграфов, полученных на прошлом этапе.

[[File:Chameleon.png|1000px|thumb|center|Рисунок 1. Общая структура алгоритма CHAMELEON]]

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

''Исходные данные'':

* Множество из n точек <math>V= {v_{ij}}</math> в метрическом пространстве, которое задано симметрической матрицей расстояний <math>A</math> размера <math>n\times n</math>.
* <math>k</math> - количество ближайших соседей для вершин, <math>k \in N, k \leq n</math>.
* <math>l</math> - наименьшее число вершин, которое может содержать наибольший подграф на 2-м этапе, <math>l \in N, l \leq n</math>.

''Обозначения'':

* <math>G = (V, E)</math> - граф, полученный путём соединения каждой точки с её <math>k</math> ближайшими соседями.

* <math>K= \{K_{i}\}</math> - разбиение множества <math>V</math> на набор попарно непересекающихся связных подмножеств, полученное в результате выполнения второй фазы алгоритма.

* <math>G_{2} = (K, E_{2})</math> - взвешенный граф, вершинами которого являются получившиеся подграфы, а ребрами - количество ребер исходного графа, соединяющих соответствующие подграфы.

* <math>C = \{C_{i}\}</math> - итоговое разбиение множества вершин графа <math>G_{2}</math> на набор кластеров.

''Вспомогательные понятия''

*<math>EC_{(C_{i},C_{j})}</math> - абсолютная взаимная связность пары кластеров <math>C_{i}, C{j}</math>. Определяется как сумма весов ребер, соединяющих вершины, принадлежащие <math>C{i}</math> c вершинами из <math>C{j}</math>. Внутренняя связность <math>EC_{(C_{i},C_{i})}</math> вычисляется как сумма ребер, входящих в разделитель, разбивающий <math>C{i}</math> на два равных подграфа.

*<math>RI_{(C_{i},C_{j})} = \frac{|EC_{(C_{i},C_{j})}|}{(|EC_{C_{i}}|+|EC_{C_{j}}|)/2}</math> - относительная взаимная связность пары кластеров <math>C_{i}, C{j}</math>

*<math>S_{EC_{(C_{i},C_{j})}}</math> - абсолютное взаимное сходство пары кластеров <math>C_{i}, C{j}</math>. Подсчитывается как среднее сходство между соединенными вершинами, принадлежащими <math>C{i}</math> и <math>C{j}</math> соответственно. Соединения обусловлены разбиением общего графа, полученного на первом этапе алгоритма.

*<math> RC_{(C_{i},C_{j})}= \frac{S_{EC_{(C_{i},C_{j})}}}{\frac{|C_{i}|}{|C_{i}+C_{j}|}*S_{EC_{(C_{i})}}+\frac{|C_{i}|}{|C_{i}+C_{j}|}*S_{EC_{(C_{j})}}}</math> - относительное взаимное сходство пары кластеров <math>C_{i}, C{j}</math>. Определяется как абсолютное сходство между этой парой кластеров, нормализованное с учетом их внутреннего сходства<ref>https://algowiki-project.org/algowiki/ru/index.php?title=Участник:ЕкатеринаКозырева/Алгоритм_динамической_иерархической_кластеризации_CHAMELEON</ref>.

'''Первый этап'''

На первом этапе, согласно графо-ориентированному подходу, происходит построение графа <math>G = (V, E)</math> на матрице сходства объектов по принципу k ближайших соседей. Две вершины такого графа соединяет ребро, если объект, соответствующий любой из этих вершин попадает в число k наиболее близких объектов для объекта, соответствующего другой вершине из данной пары.
[[Файл:Снимок chameleon 2.png|2000px|thumb|Рисунок 2. Объекты в пространстве - слева, граф по принципу 1-го ближайшего соседа - по центру, граф по принципу 3-х ближайших соседей - справа ]]

'''Второй этап'''

Алгоритм разделяет полученный граф на множество сравнительно малых подграфов <math>K= \{K_{i}\}</math>. Разделение происходит последовательно. На каждом шаге выбирается подграф, содержащий наибольшее число вершин. Этот граф разделяется на два подграфа так, что разделитель ребер графа минимален и каждый из получаемых подграфов содержит не менее 25 % вершин исходного графа. Процесс разделения останавливается, когда наибольший подграф содержит меньше некоторого заданного числа вершин. Обычно величина этого параметра задается равной значению от 1 до 5 % от числа объектов. Полученное множество связных графов считается множеством начальных кластеров, на котором требуется провести последовательное иерархическое объединение.

'''Третий этап'''

Третий этап заключается в итеративном преобразовании множества подграфов <math>K= \{K_{i}\}</math> в множество кластеров <math>C = \{C_{i}\}</math>. Алгоритм осуществляет агломеративную иерархическую кластеризацию на основании показателей <math>EC_{(C_{i},C_{j})}</math>, <math>S_{EC_{(C_{i},C_{j})}}</math>, <math>RI_{(C_{i},C_{j})} </math>, <math> RC_{(C_{i},C_{j})}</math>. Существует две стратегии анализа показателей сходства. Первая подразумевает наличие некоторых пороговых значений <math>T_{RI}</math> и <math>T_{RC}</math>. В соответствии с этой стратегией, алгоритм для каждого кластера <math>C_{i}</math> проверяет, отвечают ли смежные (наиболее близкие) ему кластеры условиям:

*<math>RI_{(C_{i},C_{j})} \geqslant T_{RI}</math>

*<math>RC_{(C_{i},C_{j})} \geqslant T_{RC}</math>

Если более одного смежного кластера отвечает этим условиям, то алгоритм выбирает для объединения наиболее связный кластер (граф), то есть такой кластер <math>C_{j}</math>, с которым у кластера <math>C_{i}</math> получается наибольшая абсолютная взаимная связность. По завершению прохода по всем кластерам, созданные таким образом пары объединяются. Параметры <math>T_{RI}</math> и <math>T_{RC}</math> могут использоваться для изменения характеристик получаемых кластеров.

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

<math>RI_{(C_{i},C_{j})}*RC_{(C_{i},C_{j})}^\alpha</math>,

где <math>\alpha</math> выбирается пользователем. Если <math>\alpha > 1 </math>, то алгоритм придает большее значение относительному взаимному сходству, а если <math>\alpha < 1 </math>, то большее значение имеет относительная взаимная связность.

''Вычисляемые данные'':

<math>U = (u_1, u_2, ..., u_n)</math> - n-мерный вектор, где <math>u_i \in N_{[C]}</math> - порядковый номер кластера, к которому принадлежит вершина i исходного множества V.

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

Алгоритм имеет три вычислительных ядра, по одному на каждый этап.

На первом этапе вычислительным ядром является процесс нахождения <math>k</math> ближайших соседей для каждой вершины, который заключается в анализе матрицы расстояний.

На втором этапе вычислительным ядром является процесс поиска подходящего разбиения очередного подграфа на два графа с минимизацией разделителя ребер графа.

На третьем этапе вычислительным ядром является расчет величин <math>EC_{(C_{i},C_{j})}</math>, <math>S_{EC_{(C_{i},C_{j})}}</math>, <math>RI_{(C_{i},C_{j})} </math>, <math> RC_{(C_{i},C_{j})}</math> для каждой пары смежных кластеров.

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

Как уже рассказывалось ранее, алгоритм включает в себя три основных этапа, каждый из которых, по сути, является отдельным алгоритмом. Этапы выполняются последовательно относительно друг друга.

Макрооперация на первом этапе - процедура нахождения <math>k</math> ближайших соседей, на втором - процедура разбиения наибольшего подграфа на два графа, на третьем - процедура вычисления показателей сходства, на основе которых принимается решение о слиянии подграфов в кластер.

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

'''Первый этап'''
<source lang="cpp">
int n; //количество вершин
int k; //количество соседей
int A[n][n] //матрица расстояний
int D[k] //массив вершин-соседей
int E[n][n] //матрица ребер графа <math>G_{2} = (K, E_{2})</math>
for i=1 to n-1 do
{
for j=i+1 to n do
{
//заполняем массив вершин-соседей вставляя новые вершины, если они ближе, чем самая далекая из массива.
}
for j=0 to k do
{
//для каждой вершины соседа заполняем соответствующую ячейку из матрицы E[n][n] единицей
}

}
</source>

'''Второй этап'''

1. Все связные подграфы в отсортированном порядке помещаются в список;
2. Берем наибольший элемент списка, вычисляем количество его вершин. Если число вершин > l, то идем в пункт 3. Иначе в пункт 5;
3. Разбиваем подграф на два подграфа таким образом, чтобы разделитель ребер графа был минимален и каждый из получаемых подграфов содержал не менее 25 % вершин исходного графа;
4. Добавляем полученные элементы в список подграфов таким образом, чтобы список оставался отсортированным. Идем в пункт 2;
5. Нашли искомое множество подграфов math>K = \{K_{i}\}</math>;
6. Создаем и заполняем матрицу матрицу расстояний для графа <math>G_{2} = (K, E_{2})</math>. Получаем искомый набор рёбер <math>E_{2}</math>.

'''Третий этап'''

1. Заводим два массива: а) массив кластеров C, полученных на предыдущем этапе, б) массив объединений кластеров F, которые мы будем получать на этом этапе;
2. Берем следующий кластер <math>C_{i}</math> (на первом шаге - первый). Если все кластеры просмотрены, идем в пункт 6;
3. Берем следующий кластер <math>C_{j}, i<>j</math>. Если все кластеры просмотрены, то идем в пункт 2;
4. Проверяем смежность <math>C_{i}</math> и <math>C_{j}</math>. Если не смежны, то возвращаемся в пункт 3. Если смежны, идем в пункт 5;
5. Рассчитываем показатели <math>RI_{(C_{i},C_{j})}</math> и <math> RC_{(C_{i},C_{j})}</math>. Проверяем, удовлетворяют ли найденные значения условиям:
*<math>RI_{(C_{i},C_{j})} \geqslant T_{RI}</math>
*<math>RC_{(C_{i},C_{j})} \geqslant T_{RC}</math>
Если нет, то идем в пункт 3. Иначе если смежность пары кластеров выше, чем у предыдущих найденных, то <math>F_{i}=j</math>. Идем в пункт 3;
6. Если в списке F есть хотя бы одна пара кластеров для слияния, то выполняем слияние, обновляем массив кластеров и массив объединений кластеров. Идем в пункт 2.

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

1) Для построения графа на основе метода k ближайших соседей для n вершин требуется <math>O(n log(n))</math> операций [3]; для наборов данных большой размерности эта величина составляет <math>O(n^2)</math> операций [4];

2) Для выделения множества сравнительно малых связных подграфов требуется <math>nm</math> операций, где <math>m</math> - количество подграфов, полученных на втором этапе алгоритма;

3) Формирование набора кластеров, на основе множества подграфов, полученных на предыдущем этапе, требует <math>m^2log(m)</math> операций.

Итого, для n вершин получаем последовательную сложность <math>O(n log(n)+nm+m^2log(m))</math>.

== Информационный граф ==
[[File:СК.png]]

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

Первый этап работы алгоритма можно распределить между <math>n</math> процессами. На вход каждому процессу подается своя вершина, далее происходит процедура поиска <math>k</math> ближайших соседей. Параллельная сложность составляет <math>O(n)</math>.

Второй и третий этапы можно распараллелить частично.

Второй этап распараллеливается путем подачи на вход свободному процессу очередного подграфа для разделения. Число итераций оценивается в <math>O(n log(n))</math>.

Третий этап делится на расчет показателей схожести и соединение подграфов в кластеры. Процесс расчета показателей можно распараллелить, подавая каждому процессу на вход пару подграфов. Сложность этого процесса оценивается как <math>m log(m)</math>. Соединение подграфов в кластеры выполняется последовательно, сложность процесса составляет <math>m^2 log(m)</math>

Таким образом получаем общую параллельную сложность алгоритма: <math>O(n+ n log(n) + m^2 log (m) + m log(m))</math>

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

1. Симметрическая матрица <math>A</math> расстояний между элементами данных размера <math>n\times n</math> с нулями на главной диагонали (<math>a_{ii}= 0, i = 1, \ldots, N</math>).

2. <math>k</math> - количество ближайших соседей для вершин (рекомендуемое значение <math>k</math> от 5 до 20 в зависимости от количества анализируемых объектов).

3. <math>l</math> - наименьшее число вершин, которое может содержать наибольший подкластер на 2-м этапе . Величина этого параметра варьируется от 1 до 5 % от общего числа объектов.

'''Объём входных данных'''

<math>\frac{n (n - 1)}{2}</math> (в силу симметричности и нулевой главной диагонали достаточно хранить только над/поддиагональные элементы).

'''Выходные данные'''

Вектор из <math>n</math> чисел <math>u_{1}, u_{2}, \ldots, u_{N}</math>, где <math>u_{i}</math> - целое число, соответствующее кластеру <math>i</math>-го объекта.

'''Объём выходных данных'''

<math>n</math>

== Свойства алгоритма ==
Соотношение последовательной и параллельной сложности на первом этапе является ''линейным'' для больших наборов данных и логарифмическим для n вершин. На втором этапе сложно оценить это соотношение - оно сильно зависит от параметров <math>k</math> и <math>l</math>. На третьем этапе соотношение равно <math>O(1)</math>

Алгоритм является недетерминированным. Хотя 1-й этап детерминирован, на 2-ом этапе могут быть найдены различные разбиения на подграфы, что повлияет и на итоговый результат работы алгоритма.

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

см. позднее

== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Последовательная реализация алгоритма доступна по ссылке <ref>http://www.codeforge.com/article/192925</ref>.

CHAMELEON можно реализовать с использованием графовых библиотек METIS <ref>http://glaros.dtc.umn.edu/gkhome/metis/metis/overview
</ref>, hMETIS <ref>http://glaros.dtc.umn.edu/gkhome/metis/hmetis/overview</ref> и RANN <ref>https://cran.r-project.org/web/packages/RANN/index.html</ref>.

Существует исследование, связанное с реализацией CHAMELEON посредством технологии OpenMP, с которым можно ознакомиться здесь <ref>http://research.ijcaonline.org/volume79/number8/pxc3891600.pdf</ref>.

Параллельных реализаций алгоритма CHAMELEON не найдено.

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

[2] http://studopedia.ru/7_41934_algoritm-dinamicheskoy-ierarhicheskoy-klasterizatsii-CHAMELEON.html

[3] J.H. Friedman, J.L. Bentley, and R.A. Finkel. An algorithm for ﬁnding best matches in logarithmic expected time. ACM Transactions on Mathematical Software, 3:209–226, 1977.

[4] S. Berchtold, C. Bohm, D. Keim, and H.-P. Kriegel. Cost model for nearest neighbor search in high dimensional data space. In Proc. of Symposium on Principles of Database Systems, Tucson, Arizona, 1997.

Участник:ЕкатеринаКозырева/Алгоритм динамической иерархической кластеризации CHAMELEON

2016-10-31T18:48:42Z

ЕкатеринаКозырева: /* Литература */

{{algorithm
| name = Алгоритм динамической иерархической кластеризации CHAMELEON
| serial_complexity = <math>O(nm + n log n + m^2 log m)</math>
| input_data = <math>\frac{n (n - 1)}{2}</math>
| output_data = <math>n</math>
| pf_height = <math>O(n+ n log(n) + m^2 log (m) + m log(m))</math>
| pf_width = <math>O(n)</math>
}}

Автор описания [[Участник:ЕкатеринаКозырева|Е.А.Козырева]]
= Свойства и структура алгоритмов =

== Общее описание алгоритма ==
Алгоритм CHAMELEON был предложен в 1999 году тремя учеными из университета Миннесоты – George Karypis, Eui-Hong (Sam) Han и Vipin Kumar<ref>George Karypis, Eui-Hong (Sam) Han и Vipin Kumar, «Chameleon: Hierarchical Clustering Using Dynamic Modeling», 1999.</ref>.

Предназначен для решения задач кластеризации. Кластеризация (или кластерный анализ) — это задача разбиения множества объектов на группы, называемые кластерами. Внутри каждой группы должны оказаться «похожие» объекты, а объекты разных группы должны быть как можно более отличны.

CHAMELEON - это агломеративный иерархический алгоритм кластеризации, ключевой особенностью которого является то, что он учитывает и взаимную связность, и сходство при определении наиболее похожей пары подкластеров, основываясь на динамической модели. Это означает, что в процессе кластеризации два кластера объединяются, только если их относительная взаимная связность и относительное взаимное сходство являются высокими по отношению к внутренней взаимосвязанности кластеров и близости элементов внутри кластеров. Кроме того, CHAMELEON использует подход для моделирования степени взаимосвязанности и близости между каждой парой кластеров, который учитывает внутренние характеристики самих кластеров. Таким образом, он может автоматически адаптироваться к внутренним характеристикам объединяемых кластеров.

CHAMELEON находит кластеры в наборе данных с помощью трехфазного алгоритма. На первой фазе происходит построение графа, путём добавления рёбер по принципу k ближайших соседей. На второй фазе CHAMELEON группирует полученные элементы в множество относительно небольших подграфов. Во время третьей фазы применяется агломеративный иерархический алгоритм кластеризации, с помощью которого находятся естесственные кластеры путем многократного объединения подграфов, полученных на прошлом этапе.

[[File:Chameleon.png|1000px|thumb|center|Рисунок 1. Общая структура алгоритма CHAMELEON]]

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

''Исходные данные'':

* Множество из n точек <math>V= {v_{ij}}</math> в метрическом пространстве, которое задано симметрической матрицей расстояний <math>A</math> размера <math>n\times n</math>.
* <math>k</math> - количество ближайших соседей для вершин, <math>k \in N, k \leq n</math>.
* <math>l</math> - наименьшее число вершин, которое может содержать наибольший подграф на 2-м этапе, <math>l \in N, l \leq n</math>.

''Обозначения'':

* <math>G = (V, E)</math> - граф, полученный путём соединения каждой точки с её <math>k</math> ближайшими соседями.

* <math>K= \{K_{i}\}</math> - разбиение множества <math>V</math> на набор попарно непересекающихся связных подмножеств, полученное в результате выполнения второй фазы алгоритма.

* <math>G_{2} = (K, E_{2})</math> - взвешенный граф, вершинами которого являются получившиеся подграфы, а ребрами - количество ребер исходного графа, соединяющих соответствующие подграфы.

* <math>C = \{C_{i}\}</math> - итоговое разбиение множества вершин графа <math>G_{2}</math> на набор кластеров.

''Вспомогательные понятия''

*<math>EC_{(C_{i},C_{j})}</math> - абсолютная взаимная связность пары кластеров <math>C_{i}, C{j}</math>. Определяется как сумма весов ребер, соединяющих вершины, принадлежащие <math>C{i}</math> c вершинами из <math>C{j}</math>. Внутренняя связность <math>EC_{(C_{i},C_{i})}</math> вычисляется как сумма ребер, входящих в разделитель, разбивающий <math>C{i}</math> на два равных подграфа.

*<math>RI_{(C_{i},C_{j})} = \frac{|EC_{(C_{i},C_{j})}|}{(|EC_{C_{i}}|+|EC_{C_{j}}|)/2}</math> - относительная взаимная связность пары кластеров <math>C_{i}, C{j}</math>

*<math>S_{EC_{(C_{i},C_{j})}}</math> - абсолютное взаимное сходство пары кластеров <math>C_{i}, C{j}</math>. Подсчитывается как среднее сходство между соединенными вершинами, принадлежащими <math>C{i}</math> и <math>C{j}</math> соответственно. Соединения обусловлены разбиением общего графа, полученного на первом этапе алгоритма.

*<math> RC_{(C_{i},C_{j})}= \frac{S_{EC_{(C_{i},C_{j})}}}{\frac{|C_{i}|}{|C_{i}+C_{j}|}*S_{EC_{(C_{i})}}+\frac{|C_{i}|}{|C_{i}+C_{j}|}*S_{EC_{(C_{j})}}}</math> - относительное взаимное сходство пары кластеров <math>C_{i}, C{j}</math>. Определяется как абсолютное сходство между этой парой кластеров, нормализованное с учетом их внутреннего сходства.

'''Первый этап'''

На первом этапе, согласно графо-ориентированному подходу, происходит построение графа <math>G = (V, E)</math> на матрице сходства объектов по принципу k ближайших соседей. Две вершины такого графа соединяет ребро, если объект, соответствующий любой из этих вершин попадает в число k наиболее близких объектов для объекта, соответствующего другой вершине из данной пары.
[[Файл:Снимок chameleon 2.png|2000px|thumb|Рисунок 2. Объекты в пространстве - слева, граф по принципу 1-го ближайшего соседа - по центру, граф по принципу 3-х ближайших соседей - справа ]]

'''Второй этап'''

Алгоритм разделяет полученный граф на множество сравнительно малых подграфов <math>K= \{K_{i}\}</math>. Разделение происходит последовательно. На каждом шаге выбирается подграф, содержащий наибольшее число вершин. Этот граф разделяется на два подграфа так, что разделитель ребер графа минимален и каждый из получаемых подграфов содержит не менее 25 % вершин исходного графа. Процесс разделения останавливается, когда наибольший подграф содержит меньше некоторого заданного числа вершин. Обычно величина этого параметра задается равной значению от 1 до 5 % от числа объектов. Полученное множество связных графов считается множеством начальных кластеров, на котором требуется провести последовательное иерархическое объединение.

'''Третий этап'''

Третий этап заключается в итеративном преобразовании множества подграфов <math>K= \{K_{i}\}</math> в множество кластеров <math>C = \{C_{i}\}</math>. Алгоритм осуществляет агломеративную иерархическую кластеризацию на основании показателей <math>EC_{(C_{i},C_{j})}</math>, <math>S_{EC_{(C_{i},C_{j})}}</math>, <math>RI_{(C_{i},C_{j})} </math>, <math> RC_{(C_{i},C_{j})}</math>. Существует две стратегии анализа показателей сходства. Первая подразумевает наличие некоторых пороговых значений <math>T_{RI}</math> и <math>T_{RC}</math>. В соответствии с этой стратегией, алгоритм для каждого кластера <math>C_{i}</math> проверяет, отвечают ли смежные (наиболее близкие) ему кластеры условиям:

*<math>RI_{(C_{i},C_{j})} \geqslant T_{RI}</math>

*<math>RC_{(C_{i},C_{j})} \geqslant T_{RC}</math>

Если более одного смежного кластера отвечает этим условиям, то алгоритм выбирает для объединения наиболее связный кластер (граф), то есть такой кластер <math>C_{j}</math>, с которым у кластера <math>C_{i}</math> получается наибольшая абсолютная взаимная связность. По завершению прохода по всем кластерам, созданные таким образом пары объединяются. Параметры <math>T_{RI}</math> и <math>T_{RC}</math> могут использоваться для изменения характеристик получаемых кластеров.

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

<math>RI_{(C_{i},C_{j})}*RC_{(C_{i},C_{j})}^\alpha</math>,

где <math>\alpha</math> выбирается пользователем. Если <math>\alpha > 1 </math>, то алгоритм придает большее значение относительному взаимному сходству, а если <math>\alpha < 1 </math>, то большее значение имеет относительная взаимная связность.

''Вычисляемые данные'':

<math>U = (u_1, u_2, ..., u_n)</math> - n-мерный вектор, где <math>u_i \in N_{[C]}</math> - порядковый номер кластера, к которому принадлежит вершина i исходного множества V.

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

Алгоритм имеет три вычислительных ядра, по одному на каждый этап.

На первом этапе вычислительным ядром является процесс нахождения <math>k</math> ближайших соседей для каждой вершины, который заключается в анализе матрицы расстояний.

На втором этапе вычислительным ядром является процесс поиска подходящего разбиения очередного подграфа на два графа с минимизацией разделителя ребер графа.

На третьем этапе вычислительным ядром является расчет величин <math>EC_{(C_{i},C_{j})}</math>, <math>S_{EC_{(C_{i},C_{j})}}</math>, <math>RI_{(C_{i},C_{j})} </math>, <math> RC_{(C_{i},C_{j})}</math> для каждой пары смежных кластеров.

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

Как уже рассказывалось ранее, алгоритм включает в себя три основных этапа, каждый из которых, по сути, является отдельным алгоритмом. Этапы выполняются последовательно относительно друг друга.

Макрооперация на первом этапе - процедура нахождения <math>k</math> ближайших соседей, на втором - процедура разбиения наибольшего подграфа на два графа, на третьем - процедура вычисления показателей сходства, на основе которых принимается решение о слиянии подграфов в кластер.

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

'''Первый этап'''
<source lang="cpp">
int n; //количество вершин
int k; //количество соседей
int A[n][n] //матрица расстояний
int D[k] //массив вершин-соседей
int E[n][n] //матрица ребер графа <math>G_{2} = (K, E_{2})</math>
for i=1 to n-1 do
{
for j=i+1 to n do
{
//заполняем массив вершин-соседей вставляя новые вершины, если они ближе, чем самая далекая из массива.
}
for j=0 to k do
{
//для каждой вершины соседа заполняем соответствующую ячейку из матрицы E[n][n] единицей
}

}
</source>

'''Второй этап'''

1. Все связные подграфы в отсортированном порядке помещаются в список;
2. Берем наибольший элемент списка, вычисляем количество его вершин. Если число вершин > l, то идем в пункт 3. Иначе в пункт 5;
3. Разбиваем подграф на два подграфа таким образом, чтобы разделитель ребер графа был минимален и каждый из получаемых подграфов содержал не менее 25 % вершин исходного графа;
4. Добавляем полученные элементы в список подграфов таким образом, чтобы список оставался отсортированным. Идем в пункт 2;
5. Нашли искомое множество подграфов math>K = \{K_{i}\}</math>;
6. Создаем и заполняем матрицу матрицу расстояний для графа <math>G_{2} = (K, E_{2})</math>. Получаем искомый набор рёбер <math>E_{2}</math>.

'''Третий этап'''

1. Заводим два массива: а) массив кластеров C, полученных на предыдущем этапе, б) массив объединений кластеров F, которые мы будем получать на этом этапе;
2. Берем следующий кластер <math>C_{i}</math> (на первом шаге - первый). Если все кластеры просмотрены, идем в пункт 6;
3. Берем следующий кластер <math>C_{j}, i<>j</math>. Если все кластеры просмотрены, то идем в пункт 2;
4. Проверяем смежность <math>C_{i}</math> и <math>C_{j}</math>. Если не смежны, то возвращаемся в пункт 3. Если смежны, идем в пункт 5;
5. Рассчитываем показатели <math>RI_{(C_{i},C_{j})}</math> и <math> RC_{(C_{i},C_{j})}</math>. Проверяем, удовлетворяют ли найденные значения условиям:
*<math>RI_{(C_{i},C_{j})} \geqslant T_{RI}</math>
*<math>RC_{(C_{i},C_{j})} \geqslant T_{RC}</math>
Если нет, то идем в пункт 3. Иначе если смежность пары кластеров выше, чем у предыдущих найденных, то <math>F_{i}=j</math>. Идем в пункт 3;
6. Если в списке F есть хотя бы одна пара кластеров для слияния, то выполняем слияние, обновляем массив кластеров и массив объединений кластеров. Идем в пункт 2.

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

1) Для построения графа на основе метода k ближайших соседей для n вершин требуется <math>O(n log(n))</math> операций [3]; для наборов данных большой размерности эта величина составляет <math>O(n^2)</math> операций [4];

2) Для выделения множества сравнительно малых связных подграфов требуется <math>nm</math> операций, где <math>m</math> - количество подграфов, полученных на втором этапе алгоритма;

3) Формирование набора кластеров, на основе множества подграфов, полученных на предыдущем этапе, требует <math>m^2log(m)</math> операций.

Итого, для n вершин получаем последовательную сложность <math>O(n log(n)+nm+m^2log(m))</math>.

== Информационный граф ==
[[File:СК.png]]

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

Первый этап работы алгоритма можно распределить между <math>n</math> процессами. На вход каждому процессу подается своя вершина, далее происходит процедура поиска <math>k</math> ближайших соседей. Параллельная сложность составляет <math>O(n)</math>.

Второй и третий этапы можно распараллелить частично.

Второй этап распараллеливается путем подачи на вход свободному процессу очередного подграфа для разделения. Число итераций оценивается в <math>O(n log(n))</math>.

Третий этап делится на расчет показателей схожести и соединение подграфов в кластеры. Процесс расчета показателей можно распараллелить, подавая каждому процессу на вход пару подграфов. Сложность этого процесса оценивается как <math>m log(m)</math>. Соединение подграфов в кластеры выполняется последовательно, сложность процесса составляет <math>m^2 log(m)</math>

Таким образом получаем общую параллельную сложность алгоритма: <math>O(n+ n log(n) + m^2 log (m) + m log(m))</math>

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

1. Симметрическая матрица <math>A</math> расстояний между элементами данных размера <math>n\times n</math> с нулями на главной диагонали (<math>a_{ii}= 0, i = 1, \ldots, N</math>).

2. <math>k</math> - количество ближайших соседей для вершин (рекомендуемое значение <math>k</math> от 5 до 20 в зависимости от количества анализируемых объектов).

3. <math>l</math> - наименьшее число вершин, которое может содержать наибольший подкластер на 2-м этапе . Величина этого параметра варьируется от 1 до 5 % от общего числа объектов.

'''Объём входных данных'''

<math>\frac{n (n - 1)}{2}</math> (в силу симметричности и нулевой главной диагонали достаточно хранить только над/поддиагональные элементы).

'''Выходные данные'''

Вектор из <math>n</math> чисел <math>u_{1}, u_{2}, \ldots, u_{N}</math>, где <math>u_{i}</math> - целое число, соответствующее кластеру <math>i</math>-го объекта.

'''Объём выходных данных'''

<math>n</math>

== Свойства алгоритма ==
Соотношение последовательной и параллельной сложности на первом этапе является ''линейным'' для больших наборов данных и логарифмическим для n вершин. На втором этапе сложно оценить это соотношение - оно сильно зависит от параметров <math>k</math> и <math>l</math>. На третьем этапе соотношение равно <math>O(1)</math>

Алгоритм является недетерминированным. Хотя 1-й этап детерминирован, на 2-ом этапе могут быть найдены различные разбиения на подграфы, что повлияет и на итоговый результат работы алгоритма.

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

см. позднее

== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Последовательная реализация алгоритма доступна по ссылке <ref>http://www.codeforge.com/article/192925</ref>.

CHAMELEON можно реализовать с использованием графовых библиотек METIS <ref>http://glaros.dtc.umn.edu/gkhome/metis/metis/overview
</ref>, hMETIS <ref>http://glaros.dtc.umn.edu/gkhome/metis/hmetis/overview</ref> и RANN <ref>https://cran.r-project.org/web/packages/RANN/index.html</ref>.

Существует исследование, связанное с реализацией CHAMELEON посредством технологии OpenMP, с которым можно ознакомиться здесь <ref>http://research.ijcaonline.org/volume79/number8/pxc3891600.pdf</ref>.

Параллельных реализаций алгоритма CHAMELEON не найдено.

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

[2] http://studopedia.ru/7_41934_algoritm-dinamicheskoy-ierarhicheskoy-klasterizatsii-CHAMELEON.html

[3] J.H. Friedman, J.L. Bentley, and R.A. Finkel. An algorithm for ﬁnding best matches in logarithmic expected time. ACM Transactions on Mathematical Software, 3:209–226, 1977.

[4] S. Berchtold, C. Bohm, D. Keim, and H.-P. Kriegel. Cost model for nearest neighbor search in high dimensional data space. In Proc. of Symposium on Principles of Database Systems, Tucson, Arizona, 1997.

Участник:ЕкатеринаКозырева/Алгоритм динамической иерархической кластеризации CHAMELEON

2016-10-31T18:47:47Z

ЕкатеринаКозырева:

{{algorithm
| name = Алгоритм динамической иерархической кластеризации CHAMELEON
| serial_complexity = <math>O(nm + n log n + m^2 log m)</math>
| input_data = <math>\frac{n (n - 1)}{2}</math>
| output_data = <math>n</math>
| pf_height = <math>O(n+ n log(n) + m^2 log (m) + m log(m))</math>
| pf_width = <math>O(n)</math>
}}

Автор описания [[Участник:ЕкатеринаКозырева|Е.А.Козырева]]
= Свойства и структура алгоритмов =

== Общее описание алгоритма ==
Алгоритм CHAMELEON был предложен в 1999 году тремя учеными из университета Миннесоты – George Karypis, Eui-Hong (Sam) Han и Vipin Kumar<ref>George Karypis, Eui-Hong (Sam) Han и Vipin Kumar, «Chameleon: Hierarchical Clustering Using Dynamic Modeling», 1999.</ref>.

Предназначен для решения задач кластеризации. Кластеризация (или кластерный анализ) — это задача разбиения множества объектов на группы, называемые кластерами. Внутри каждой группы должны оказаться «похожие» объекты, а объекты разных группы должны быть как можно более отличны.

CHAMELEON - это агломеративный иерархический алгоритм кластеризации, ключевой особенностью которого является то, что он учитывает и взаимную связность, и сходство при определении наиболее похожей пары подкластеров, основываясь на динамической модели. Это означает, что в процессе кластеризации два кластера объединяются, только если их относительная взаимная связность и относительное взаимное сходство являются высокими по отношению к внутренней взаимосвязанности кластеров и близости элементов внутри кластеров. Кроме того, CHAMELEON использует подход для моделирования степени взаимосвязанности и близости между каждой парой кластеров, который учитывает внутренние характеристики самих кластеров. Таким образом, он может автоматически адаптироваться к внутренним характеристикам объединяемых кластеров.

CHAMELEON находит кластеры в наборе данных с помощью трехфазного алгоритма. На первой фазе происходит построение графа, путём добавления рёбер по принципу k ближайших соседей. На второй фазе CHAMELEON группирует полученные элементы в множество относительно небольших подграфов. Во время третьей фазы применяется агломеративный иерархический алгоритм кластеризации, с помощью которого находятся естесственные кластеры путем многократного объединения подграфов, полученных на прошлом этапе.

[[File:Chameleon.png|1000px|thumb|center|Рисунок 1. Общая структура алгоритма CHAMELEON]]

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

''Исходные данные'':

* Множество из n точек <math>V= {v_{ij}}</math> в метрическом пространстве, которое задано симметрической матрицей расстояний <math>A</math> размера <math>n\times n</math>.
* <math>k</math> - количество ближайших соседей для вершин, <math>k \in N, k \leq n</math>.
* <math>l</math> - наименьшее число вершин, которое может содержать наибольший подграф на 2-м этапе, <math>l \in N, l \leq n</math>.

''Обозначения'':

* <math>G = (V, E)</math> - граф, полученный путём соединения каждой точки с её <math>k</math> ближайшими соседями.

* <math>K= \{K_{i}\}</math> - разбиение множества <math>V</math> на набор попарно непересекающихся связных подмножеств, полученное в результате выполнения второй фазы алгоритма.

* <math>G_{2} = (K, E_{2})</math> - взвешенный граф, вершинами которого являются получившиеся подграфы, а ребрами - количество ребер исходного графа, соединяющих соответствующие подграфы.

* <math>C = \{C_{i}\}</math> - итоговое разбиение множества вершин графа <math>G_{2}</math> на набор кластеров.

''Вспомогательные понятия''

*<math>EC_{(C_{i},C_{j})}</math> - абсолютная взаимная связность пары кластеров <math>C_{i}, C{j}</math>. Определяется как сумма весов ребер, соединяющих вершины, принадлежащие <math>C{i}</math> c вершинами из <math>C{j}</math>. Внутренняя связность <math>EC_{(C_{i},C_{i})}</math> вычисляется как сумма ребер, входящих в разделитель, разбивающий <math>C{i}</math> на два равных подграфа.

*<math>RI_{(C_{i},C_{j})} = \frac{|EC_{(C_{i},C_{j})}|}{(|EC_{C_{i}}|+|EC_{C_{j}}|)/2}</math> - относительная взаимная связность пары кластеров <math>C_{i}, C{j}</math>

*<math>S_{EC_{(C_{i},C_{j})}}</math> - абсолютное взаимное сходство пары кластеров <math>C_{i}, C{j}</math>. Подсчитывается как среднее сходство между соединенными вершинами, принадлежащими <math>C{i}</math> и <math>C{j}</math> соответственно. Соединения обусловлены разбиением общего графа, полученного на первом этапе алгоритма.

*<math> RC_{(C_{i},C_{j})}= \frac{S_{EC_{(C_{i},C_{j})}}}{\frac{|C_{i}|}{|C_{i}+C_{j}|}*S_{EC_{(C_{i})}}+\frac{|C_{i}|}{|C_{i}+C_{j}|}*S_{EC_{(C_{j})}}}</math> - относительное взаимное сходство пары кластеров <math>C_{i}, C{j}</math>. Определяется как абсолютное сходство между этой парой кластеров, нормализованное с учетом их внутреннего сходства.

'''Первый этап'''

На первом этапе, согласно графо-ориентированному подходу, происходит построение графа <math>G = (V, E)</math> на матрице сходства объектов по принципу k ближайших соседей. Две вершины такого графа соединяет ребро, если объект, соответствующий любой из этих вершин попадает в число k наиболее близких объектов для объекта, соответствующего другой вершине из данной пары.
[[Файл:Снимок chameleon 2.png|2000px|thumb|Рисунок 2. Объекты в пространстве - слева, граф по принципу 1-го ближайшего соседа - по центру, граф по принципу 3-х ближайших соседей - справа ]]

'''Второй этап'''

Алгоритм разделяет полученный граф на множество сравнительно малых подграфов <math>K= \{K_{i}\}</math>. Разделение происходит последовательно. На каждом шаге выбирается подграф, содержащий наибольшее число вершин. Этот граф разделяется на два подграфа так, что разделитель ребер графа минимален и каждый из получаемых подграфов содержит не менее 25 % вершин исходного графа. Процесс разделения останавливается, когда наибольший подграф содержит меньше некоторого заданного числа вершин. Обычно величина этого параметра задается равной значению от 1 до 5 % от числа объектов. Полученное множество связных графов считается множеством начальных кластеров, на котором требуется провести последовательное иерархическое объединение.

'''Третий этап'''

Третий этап заключается в итеративном преобразовании множества подграфов <math>K= \{K_{i}\}</math> в множество кластеров <math>C = \{C_{i}\}</math>. Алгоритм осуществляет агломеративную иерархическую кластеризацию на основании показателей <math>EC_{(C_{i},C_{j})}</math>, <math>S_{EC_{(C_{i},C_{j})}}</math>, <math>RI_{(C_{i},C_{j})} </math>, <math> RC_{(C_{i},C_{j})}</math>. Существует две стратегии анализа показателей сходства. Первая подразумевает наличие некоторых пороговых значений <math>T_{RI}</math> и <math>T_{RC}</math>. В соответствии с этой стратегией, алгоритм для каждого кластера <math>C_{i}</math> проверяет, отвечают ли смежные (наиболее близкие) ему кластеры условиям:

*<math>RI_{(C_{i},C_{j})} \geqslant T_{RI}</math>

*<math>RC_{(C_{i},C_{j})} \geqslant T_{RC}</math>

Если более одного смежного кластера отвечает этим условиям, то алгоритм выбирает для объединения наиболее связный кластер (граф), то есть такой кластер <math>C_{j}</math>, с которым у кластера <math>C_{i}</math> получается наибольшая абсолютная взаимная связность. По завершению прохода по всем кластерам, созданные таким образом пары объединяются. Параметры <math>T_{RI}</math> и <math>T_{RC}</math> могут использоваться для изменения характеристик получаемых кластеров.

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

<math>RI_{(C_{i},C_{j})}*RC_{(C_{i},C_{j})}^\alpha</math>,

где <math>\alpha</math> выбирается пользователем. Если <math>\alpha > 1 </math>, то алгоритм придает большее значение относительному взаимному сходству, а если <math>\alpha < 1 </math>, то большее значение имеет относительная взаимная связность.

''Вычисляемые данные'':

<math>U = (u_1, u_2, ..., u_n)</math> - n-мерный вектор, где <math>u_i \in N_{[C]}</math> - порядковый номер кластера, к которому принадлежит вершина i исходного множества V.

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

Алгоритм имеет три вычислительных ядра, по одному на каждый этап.

На первом этапе вычислительным ядром является процесс нахождения <math>k</math> ближайших соседей для каждой вершины, который заключается в анализе матрицы расстояний.

На втором этапе вычислительным ядром является процесс поиска подходящего разбиения очередного подграфа на два графа с минимизацией разделителя ребер графа.

На третьем этапе вычислительным ядром является расчет величин <math>EC_{(C_{i},C_{j})}</math>, <math>S_{EC_{(C_{i},C_{j})}}</math>, <math>RI_{(C_{i},C_{j})} </math>, <math> RC_{(C_{i},C_{j})}</math> для каждой пары смежных кластеров.

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

Как уже рассказывалось ранее, алгоритм включает в себя три основных этапа, каждый из которых, по сути, является отдельным алгоритмом. Этапы выполняются последовательно относительно друг друга.

Макрооперация на первом этапе - процедура нахождения <math>k</math> ближайших соседей, на втором - процедура разбиения наибольшего подграфа на два графа, на третьем - процедура вычисления показателей сходства, на основе которых принимается решение о слиянии подграфов в кластер.

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

'''Первый этап'''
<source lang="cpp">
int n; //количество вершин
int k; //количество соседей
int A[n][n] //матрица расстояний
int D[k] //массив вершин-соседей
int E[n][n] //матрица ребер графа <math>G_{2} = (K, E_{2})</math>
for i=1 to n-1 do
{
for j=i+1 to n do
{
//заполняем массив вершин-соседей вставляя новые вершины, если они ближе, чем самая далекая из массива.
}
for j=0 to k do
{
//для каждой вершины соседа заполняем соответствующую ячейку из матрицы E[n][n] единицей
}

}
</source>

'''Второй этап'''

1. Все связные подграфы в отсортированном порядке помещаются в список;
2. Берем наибольший элемент списка, вычисляем количество его вершин. Если число вершин > l, то идем в пункт 3. Иначе в пункт 5;
3. Разбиваем подграф на два подграфа таким образом, чтобы разделитель ребер графа был минимален и каждый из получаемых подграфов содержал не менее 25 % вершин исходного графа;
4. Добавляем полученные элементы в список подграфов таким образом, чтобы список оставался отсортированным. Идем в пункт 2;
5. Нашли искомое множество подграфов math>K = \{K_{i}\}</math>;
6. Создаем и заполняем матрицу матрицу расстояний для графа <math>G_{2} = (K, E_{2})</math>. Получаем искомый набор рёбер <math>E_{2}</math>.

'''Третий этап'''

1. Заводим два массива: а) массив кластеров C, полученных на предыдущем этапе, б) массив объединений кластеров F, которые мы будем получать на этом этапе;
2. Берем следующий кластер <math>C_{i}</math> (на первом шаге - первый). Если все кластеры просмотрены, идем в пункт 6;
3. Берем следующий кластер <math>C_{j}, i<>j</math>. Если все кластеры просмотрены, то идем в пункт 2;
4. Проверяем смежность <math>C_{i}</math> и <math>C_{j}</math>. Если не смежны, то возвращаемся в пункт 3. Если смежны, идем в пункт 5;
5. Рассчитываем показатели <math>RI_{(C_{i},C_{j})}</math> и <math> RC_{(C_{i},C_{j})}</math>. Проверяем, удовлетворяют ли найденные значения условиям:
*<math>RI_{(C_{i},C_{j})} \geqslant T_{RI}</math>
*<math>RC_{(C_{i},C_{j})} \geqslant T_{RC}</math>
Если нет, то идем в пункт 3. Иначе если смежность пары кластеров выше, чем у предыдущих найденных, то <math>F_{i}=j</math>. Идем в пункт 3;
6. Если в списке F есть хотя бы одна пара кластеров для слияния, то выполняем слияние, обновляем массив кластеров и массив объединений кластеров. Идем в пункт 2.

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

1) Для построения графа на основе метода k ближайших соседей для n вершин требуется <math>O(n log(n))</math> операций [3]; для наборов данных большой размерности эта величина составляет <math>O(n^2)</math> операций [4];

2) Для выделения множества сравнительно малых связных подграфов требуется <math>nm</math> операций, где <math>m</math> - количество подграфов, полученных на втором этапе алгоритма;

3) Формирование набора кластеров, на основе множества подграфов, полученных на предыдущем этапе, требует <math>m^2log(m)</math> операций.

Итого, для n вершин получаем последовательную сложность <math>O(n log(n)+nm+m^2log(m))</math>.

== Информационный граф ==
[[File:СК.png]]

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

Первый этап работы алгоритма можно распределить между <math>n</math> процессами. На вход каждому процессу подается своя вершина, далее происходит процедура поиска <math>k</math> ближайших соседей. Параллельная сложность составляет <math>O(n)</math>.

Второй и третий этапы можно распараллелить частично.

Второй этап распараллеливается путем подачи на вход свободному процессу очередного подграфа для разделения. Число итераций оценивается в <math>O(n log(n))</math>.

Третий этап делится на расчет показателей схожести и соединение подграфов в кластеры. Процесс расчета показателей можно распараллелить, подавая каждому процессу на вход пару подграфов. Сложность этого процесса оценивается как <math>m log(m)</math>. Соединение подграфов в кластеры выполняется последовательно, сложность процесса составляет <math>m^2 log(m)</math>

Таким образом получаем общую параллельную сложность алгоритма: <math>O(n+ n log(n) + m^2 log (m) + m log(m))</math>

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

1. Симметрическая матрица <math>A</math> расстояний между элементами данных размера <math>n\times n</math> с нулями на главной диагонали (<math>a_{ii}= 0, i = 1, \ldots, N</math>).

2. <math>k</math> - количество ближайших соседей для вершин (рекомендуемое значение <math>k</math> от 5 до 20 в зависимости от количества анализируемых объектов).

3. <math>l</math> - наименьшее число вершин, которое может содержать наибольший подкластер на 2-м этапе . Величина этого параметра варьируется от 1 до 5 % от общего числа объектов.

'''Объём входных данных'''

<math>\frac{n (n - 1)}{2}</math> (в силу симметричности и нулевой главной диагонали достаточно хранить только над/поддиагональные элементы).

'''Выходные данные'''

Вектор из <math>n</math> чисел <math>u_{1}, u_{2}, \ldots, u_{N}</math>, где <math>u_{i}</math> - целое число, соответствующее кластеру <math>i</math>-го объекта.

'''Объём выходных данных'''

<math>n</math>

== Свойства алгоритма ==
Соотношение последовательной и параллельной сложности на первом этапе является ''линейным'' для больших наборов данных и логарифмическим для n вершин. На втором этапе сложно оценить это соотношение - оно сильно зависит от параметров <math>k</math> и <math>l</math>. На третьем этапе соотношение равно <math>O(1)</math>

Алгоритм является недетерминированным. Хотя 1-й этап детерминирован, на 2-ом этапе могут быть найдены различные разбиения на подграфы, что повлияет и на итоговый результат работы алгоритма.

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

см. позднее

== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Последовательная реализация алгоритма доступна по ссылке <ref>http://www.codeforge.com/article/192925</ref>.

CHAMELEON можно реализовать с использованием графовых библиотек METIS <ref>http://glaros.dtc.umn.edu/gkhome/metis/metis/overview
</ref>, hMETIS <ref>http://glaros.dtc.umn.edu/gkhome/metis/hmetis/overview</ref> и RANN <ref>https://cran.r-project.org/web/packages/RANN/index.html</ref>.

Существует исследование, связанное с реализацией CHAMELEON посредством технологии OpenMP, с которым можно ознакомиться здесь <ref>http://research.ijcaonline.org/volume79/number8/pxc3891600.pdf</ref>.

Параллельных реализаций алгоритма CHAMELEON не найдено.

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

[2] http://studopedia.ru/7_41934_algoritm-dinamicheskoy-ierarhicheskoy-klasterizatsii-CHAMELEON.html

[3] J.H. Friedman, J.L. Bentley, and R.A. Finkel. An algorithm for ﬁnding best matches in logarithmic expected time. ACM Transactions on Mathematical Software, 3:209–226, 1977.

[4] S. Berchtold, C. Bohm, D. Keim, and H.-P. Kriegel. Cost model for nearest neighbor search in high dimensional data space. In Proc. of Symposium on Principles of Database Systems, Tucson, Arizona, 1997.

[5] http://www.codeforge.com/article/192925

[6] http://glaros.dtc.umn.edu/gkhome/metis/metis/overview

[7] http://glaros.dtc.umn.edu/gkhome/metis/hmetis/overview

[8] https://cran.r-project.org/web/packages/RANN/index.html

[9] http://research.ijcaonline.org/volume79/number8/pxc3891600.pdf

Участник:ЕкатеринаКозырева/Алгоритм динамической иерархической кластеризации CHAMELEON

2016-10-31T18:44:52Z

ЕкатеринаКозырева: /* Математическое описание алгоритма */

{{algorithm
| name = Алгоритм динамической иерархической кластеризации CHAMELEON
| serial_complexity = <math>O(nm + n log n + m^2 log m)</math>
| input_data = <math>\frac{n (n - 1)}{2}</math>
| output_data = <math>n</math>
| pf_height = <math>O(n+ n log(n) + m^2 log (m) + m log(m))</math>
| pf_width = <math>O(n)</math>
}}

Автор описания [[Участник:ЕкатеринаКозырева|Е.А.Козырева]]
= Свойства и структура алгоритмов =

== Общее описание алгоритма ==
Алгоритм CHAMELEON был предложен в 1999 году тремя учеными из университета Миннесоты – George Karypis, Eui-Hong (Sam) Han и Vipin Kumar<ref>George Karypis, Eui-Hong (Sam) Han и Vipin Kumar, «Chameleon: Hierarchical Clustering Using Dynamic Modeling», 1999.</ref>.

Предназначен для решения задач кластеризации. Кластеризация (или кластерный анализ) — это задача разбиения множества объектов на группы, называемые кластерами. Внутри каждой группы должны оказаться «похожие» объекты, а объекты разных группы должны быть как можно более отличны.

CHAMELEON - это агломеративный иерархический алгоритм кластеризации, ключевой особенностью которого является то, что он учитывает и взаимную связность, и сходство при определении наиболее похожей пары подкластеров, основываясь на динамической модели. Это означает, что в процессе кластеризации два кластера объединяются, только если их относительная взаимная связность и относительное взаимное сходство являются высокими по отношению к внутренней взаимосвязанности кластеров и близости элементов внутри кластеров. Кроме того, CHAMELEON использует подход для моделирования степени взаимосвязанности и близости между каждой парой кластеров, который учитывает внутренние характеристики самих кластеров. Таким образом, он может автоматически адаптироваться к внутренним характеристикам объединяемых кластеров.

CHAMELEON находит кластеры в наборе данных с помощью трехфазного алгоритма. На первой фазе происходит построение графа, путём добавления рёбер по принципу k ближайших соседей. На второй фазе CHAMELEON группирует полученные элементы в множество относительно небольших подграфов. Во время третьей фазы применяется агломеративный иерархический алгоритм кластеризации, с помощью которого находятся естесственные кластеры путем многократного объединения подграфов, полученных на прошлом этапе.

[[File:Chameleon.png|1000px|thumb|center|Рисунок 1. Общая структура алгоритма CHAMELEON]]

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

''Исходные данные'':

* Множество из n точек <math>V= {v_{ij}}</math> в метрическом пространстве, которое задано симметрической матрицей расстояний <math>A</math> размера <math>n\times n</math>.
* <math>k</math> - количество ближайших соседей для вершин, <math>k \in N, k \leq n</math>.
* <math>l</math> - наименьшее число вершин, которое может содержать наибольший подграф на 2-м этапе, <math>l \in N, l \leq n</math>.

''Обозначения'':

* <math>G = (V, E)</math> - граф, полученный путём соединения каждой точки с её <math>k</math> ближайшими соседями.

* <math>K= \{K_{i}\}</math> - разбиение множества <math>V</math> на набор попарно непересекающихся связных подмножеств, полученное в результате выполнения второй фазы алгоритма.

* <math>G_{2} = (K, E_{2})</math> - взвешенный граф, вершинами которого являются получившиеся подграфы, а ребрами - количество ребер исходного графа, соединяющих соответствующие подграфы.

* <math>C = \{C_{i}\}</math> - итоговое разбиение множества вершин графа <math>G_{2}</math> на набор кластеров.

''Вспомогательные понятия''

*<math>EC_{(C_{i},C_{j})}</math> - абсолютная взаимная связность пары кластеров <math>C_{i}, C{j}</math>. Определяется как сумма весов ребер, соединяющих вершины, принадлежащие <math>C{i}</math> c вершинами из <math>C{j}</math>. Внутренняя связность <math>EC_{(C_{i},C_{i})}</math> вычисляется как сумма ребер, входящих в разделитель, разбивающий <math>C{i}</math> на два равных подграфа.

*<math>RI_{(C_{i},C_{j})} = \frac{|EC_{(C_{i},C_{j})}|}{(|EC_{C_{i}}|+|EC_{C_{j}}|)/2}</math> - относительная взаимная связность пары кластеров <math>C_{i}, C{j}</math>

*<math>S_{EC_{(C_{i},C_{j})}}</math> - абсолютное взаимное сходство пары кластеров <math>C_{i}, C{j}</math>. Подсчитывается как среднее сходство между соединенными вершинами, принадлежащими <math>C{i}</math> и <math>C{j}</math> соответственно. Соединения обусловлены разбиением общего графа, полученного на первом этапе алгоритма.

*<math> RC_{(C_{i},C_{j})}= \frac{S_{EC_{(C_{i},C_{j})}}}{\frac{|C_{i}|}{|C_{i}+C_{j}|}*S_{EC_{(C_{i})}}+\frac{|C_{i}|}{|C_{i}+C_{j}|}*S_{EC_{(C_{j})}}}</math> - относительное взаимное сходство пары кластеров <math>C_{i}, C{j}</math>. Определяется как абсолютное сходство между этой парой кластеров, нормализованное с учетом их внутреннего сходства.

'''Первый этап'''

На первом этапе, согласно графо-ориентированному подходу, происходит построение графа <math>G = (V, E)</math> на матрице сходства объектов по принципу k ближайших соседей. Две вершины такого графа соединяет ребро, если объект, соответствующий любой из этих вершин попадает в число k наиболее близких объектов для объекта, соответствующего другой вершине из данной пары.
[[Файл:Снимок chameleon 2.png|2000px|thumb|Рисунок 2. Объекты в пространстве - слева, граф по принципу 1-го ближайшего соседа - по центру, граф по принципу 3-х ближайших соседей - справа ]]

'''Второй этап'''

Алгоритм разделяет полученный граф на множество сравнительно малых подграфов <math>K= \{K_{i}\}</math>. Разделение происходит последовательно. На каждом шаге выбирается подграф, содержащий наибольшее число вершин. Этот граф разделяется на два подграфа так, что разделитель ребер графа минимален и каждый из получаемых подграфов содержит не менее 25 % вершин исходного графа. Процесс разделения останавливается, когда наибольший подграф содержит меньше некоторого заданного числа вершин. Обычно величина этого параметра задается равной значению от 1 до 5 % от числа объектов. Полученное множество связных графов считается множеством начальных кластеров, на котором требуется провести последовательное иерархическое объединение.

'''Третий этап'''

Третий этап заключается в итеративном преобразовании множества подграфов <math>K= \{K_{i}\}</math> в множество кластеров <math>C = \{C_{i}\}</math>. Алгоритм осуществляет агломеративную иерархическую кластеризацию на основании показателей <math>EC_{(C_{i},C_{j})}</math>, <math>S_{EC_{(C_{i},C_{j})}}</math>, <math>RI_{(C_{i},C_{j})} </math>, <math> RC_{(C_{i},C_{j})}</math>. Существует две стратегии анализа показателей сходства. Первая подразумевает наличие некоторых пороговых значений <math>T_{RI}</math> и <math>T_{RC}</math>. В соответствии с этой стратегией, алгоритм для каждого кластера <math>C_{i}</math> проверяет, отвечают ли смежные (наиболее близкие) ему кластеры условиям:

*<math>RI_{(C_{i},C_{j})} \geqslant T_{RI}</math>

*<math>RC_{(C_{i},C_{j})} \geqslant T_{RC}</math>

Если более одного смежного кластера отвечает этим условиям, то алгоритм выбирает для объединения наиболее связный кластер (граф), то есть такой кластер <math>C_{j}</math>, с которым у кластера <math>C_{i}</math> получается наибольшая абсолютная взаимная связность. По завершению прохода по всем кластерам, созданные таким образом пары объединяются. Параметры <math>T_{RI}</math> и <math>T_{RC}</math> могут использоваться для изменения характеристик получаемых кластеров.

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

<math>RI_{(C_{i},C_{j})}*RC_{(C_{i},C_{j})}^\alpha</math>,

где <math>\alpha</math> выбирается пользователем. Если <math>\alpha > 1 </math>, то алгоритм придает большее значение относительному взаимному сходству, а если <math>\alpha < 1 </math>, то большее значение имеет относительная взаимная связность.

''Вычисляемые данные'':

<math>U = (u_1, u_2, ..., u_n)</math> - n-мерный вектор, где <math>u_i \in N_{[C]}</math> - порядковый номер кластера, к которому принадлежит вершина i исходного множества V.

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

Алгоритм имеет три вычислительных ядра, по одному на каждый этап.

На первом этапе вычислительным ядром является процесс нахождения <math>k</math> ближайших соседей для каждой вершины, который заключается в анализе матрицы расстояний.

На втором этапе вычислительным ядром является процесс поиска подходящего разбиения очередного подграфа на два графа с минимизацией разделителя ребер графа.

На третьем этапе вычислительным ядром является расчет величин <math>EC_{(C_{i},C_{j})}</math>, <math>S_{EC_{(C_{i},C_{j})}}</math>, <math>RI_{(C_{i},C_{j})} </math>, <math> RC_{(C_{i},C_{j})}</math> для каждой пары смежных кластеров.

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

Как уже рассказывалось ранее, алгоритм включает в себя три основных этапа, каждый из которых, по сути, является отдельным алгоритмом. Этапы выполняются последовательно относительно друг друга.

Макрооперация на первом этапе - процедура нахождения <math>k</math> ближайших соседей, на втором - процедура разбиения наибольшего подграфа на два графа, на третьем - процедура вычисления показателей сходства, на основе которых принимается решение о слиянии подграфов в кластер.

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

'''Первый этап'''
<source lang="cpp">
int n; //количество вершин
int k; //количество соседей
int A[n][n] //матрица расстояний
int D[k] //массив вершин-соседей
int E[n][n] //матрица ребер графа <math>G_{2} = (K, E_{2})</math>
for i=1 to n-1 do
{
for j=i+1 to n do
{
//заполняем массив вершин-соседей вставляя новые вершины, если они ближе, чем самая далекая из массива.
}
for j=0 to k do
{
//для каждой вершины соседа заполняем соответствующую ячейку из матрицы E[n][n] единицей
}

}
</source>

'''Второй этап'''

1. Все связные подграфы в отсортированном порядке помещаются в список;
2. Берем наибольший элемент списка, вычисляем количество его вершин. Если число вершин > l, то идем в пункт 3. Иначе в пункт 5;
3. Разбиваем подграф на два подграфа таким образом, чтобы разделитель ребер графа был минимален и каждый из получаемых подграфов содержал не менее 25 % вершин исходного графа;
4. Добавляем полученные элементы в список подграфов таким образом, чтобы список оставался отсортированным. Идем в пункт 2;
5. Нашли искомое множество подграфов math>K = \{K_{i}\}</math>;
6. Создаем и заполняем матрицу матрицу расстояний для графа <math>G_{2} = (K, E_{2})</math>. Получаем искомый набор рёбер <math>E_{2}</math>.

'''Третий этап'''

1. Заводим два массива: а) массив кластеров C, полученных на предыдущем этапе, б) массив объединений кластеров F, которые мы будем получать на этом этапе;
2. Берем следующий кластер <math>C_{i}</math> (на первом шаге - первый). Если все кластеры просмотрены, идем в пункт 6;
3. Берем следующий кластер <math>C_{j}, i<>j</math>. Если все кластеры просмотрены, то идем в пункт 2;
4. Проверяем смежность <math>C_{i}</math> и <math>C_{j}</math>. Если не смежны, то возвращаемся в пункт 3. Если смежны, идем в пункт 5;
5. Рассчитываем показатели <math>RI_{(C_{i},C_{j})}</math> и <math> RC_{(C_{i},C_{j})}</math>. Проверяем, удовлетворяют ли найденные значения условиям:
*<math>RI_{(C_{i},C_{j})} \geqslant T_{RI}</math>
*<math>RC_{(C_{i},C_{j})} \geqslant T_{RC}</math>
Если нет, то идем в пункт 3. Иначе если смежность пары кластеров выше, чем у предыдущих найденных, то <math>F_{i}=j</math>. Идем в пункт 3;
6. Если в списке F есть хотя бы одна пара кластеров для слияния, то выполняем слияние, обновляем массив кластеров и массив объединений кластеров. Идем в пункт 2.

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

1) Для построения графа на основе метода k ближайших соседей для n вершин требуется <math>O(n log(n))</math> операций [3]; для наборов данных большой размерности эта величина составляет <math>O(n^2)</math> операций [4];

2) Для выделения множества сравнительно малых связных подграфов требуется <math>nm</math> операций, где <math>m</math> - количество подграфов, полученных на втором этапе алгоритма;

3) Формирование набора кластеров, на основе множества подграфов, полученных на предыдущем этапе, требует <math>m^2log(m)</math> операций.

Итого, для n вершин получаем последовательную сложность <math>O(n log(n)+nm+m^2log(m))</math>.

== Информационный граф ==
[[File:СК.png]]

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

Первый этап работы алгоритма можно распределить между <math>n</math> процессами. На вход каждому процессу подается своя вершина, далее происходит процедура поиска <math>k</math> ближайших соседей. Параллельная сложность составляет <math>O(n)</math>.

Второй и третий этапы можно распараллелить частично.

Второй этап распараллеливается путем подачи на вход свободному процессу очередного подграфа для разделения. Число итераций оценивается в <math>O(n log(n))</math>.

Третий этап делится на расчет показателей схожести и соединение подграфов в кластеры. Процесс расчета показателей можно распараллелить, подавая каждому процессу на вход пару подграфов. Сложность этого процесса оценивается как <math>m log(m)</math>. Соединение подграфов в кластеры выполняется последовательно, сложность процесса составляет <math>m^2 log(m)</math>

Таким образом получаем общую параллельную сложность алгоритма: <math>O(n+ n log(n) + m^2 log (m) + m log(m))</math>

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

1. Симметрическая матрица <math>A</math> расстояний между элементами данных размера <math>n\times n</math> с нулями на главной диагонали (<math>a_{ii}= 0, i = 1, \ldots, N</math>).

2. <math>k</math> - количество ближайших соседей для вершин (рекомендуемое значение <math>k</math> от 5 до 20 в зависимости от количества анализируемых объектов).

3. <math>l</math> - наименьшее число вершин, которое может содержать наибольший подкластер на 2-м этапе . Величина этого параметра варьируется от 1 до 5 % от общего числа объектов.

'''Объём входных данных'''

<math>\frac{n (n - 1)}{2}</math> (в силу симметричности и нулевой главной диагонали достаточно хранить только над/поддиагональные элементы).

'''Выходные данные'''

Вектор из <math>n</math> чисел <math>u_{1}, u_{2}, \ldots, u_{N}</math>, где <math>u_{i}</math> - целое число, соответствующее кластеру <math>i</math>-го объекта.

'''Объём выходных данных'''

<math>n</math>

== Свойства алгоритма ==
Соотношение последовательной и параллельной сложности на первом этапе является ''линейным'' для больших наборов данных и логарифмическим для n вершин. На втором этапе сложно оценить это соотношение - оно сильно зависит от параметров <math>k</math> и <math>l</math>. На третьем этапе соотношение равно <math>O(1)</math>

Алгоритм является недетерминированным. Хотя 1-й этап детерминирован, на 2-ом этапе могут быть найдены различные разбиения на подграфы, что повлияет и на итоговый результат работы алгоритма.

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

см. позднее

== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Последовательная реализация алгоритма доступна по ссылке [5].

CHAMELEON можно реализовать с использованием графовых библиотек METIS [6], hMETIS [7] и RANN [8].

Существует исследование, связанное с реализацией CHAMELEON посредством технологии OpenMP, с которым можно ознакомиться здесь [9].

Параллельных реализаций алгоритма CHAMELEON не найдено.

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

[2] http://studopedia.ru/7_41934_algoritm-dinamicheskoy-ierarhicheskoy-klasterizatsii-CHAMELEON.html

[3] J.H. Friedman, J.L. Bentley, and R.A. Finkel. An algorithm for ﬁnding best matches in logarithmic expected time. ACM Transactions on Mathematical Software, 3:209–226, 1977.

[4] S. Berchtold, C. Bohm, D. Keim, and H.-P. Kriegel. Cost model for nearest neighbor search in high dimensional data space. In Proc. of Symposium on Principles of Database Systems, Tucson, Arizona, 1997.

[5] http://www.codeforge.com/article/192925

[6] http://glaros.dtc.umn.edu/gkhome/metis/metis/overview

[7] http://glaros.dtc.umn.edu/gkhome/metis/hmetis/overview

[8] https://cran.r-project.org/web/packages/RANN/index.html

[9] http://research.ijcaonline.org/volume79/number8/pxc3891600.pdf

Участник:ЕкатеринаКозырева/Алгоритм динамической иерархической кластеризации CHAMELEON

2016-10-31T18:44:22Z

ЕкатеринаКозырева: /* Математическое описание алгоритма */

{{algorithm
| name = Алгоритм динамической иерархической кластеризации CHAMELEON
| serial_complexity = <math>O(nm + n log n + m^2 log m)</math>
| input_data = <math>\frac{n (n - 1)}{2}</math>
| output_data = <math>n</math>
| pf_height = <math>O(n+ n log(n) + m^2 log (m) + m log(m))</math>
| pf_width = <math>O(n)</math>
}}

Автор описания [[Участник:ЕкатеринаКозырева|Е.А.Козырева]]
= Свойства и структура алгоритмов =

== Общее описание алгоритма ==
Алгоритм CHAMELEON был предложен в 1999 году тремя учеными из университета Миннесоты – George Karypis, Eui-Hong (Sam) Han и Vipin Kumar<ref>George Karypis, Eui-Hong (Sam) Han и Vipin Kumar, «Chameleon: Hierarchical Clustering Using Dynamic Modeling», 1999.</ref>.

Предназначен для решения задач кластеризации. Кластеризация (или кластерный анализ) — это задача разбиения множества объектов на группы, называемые кластерами. Внутри каждой группы должны оказаться «похожие» объекты, а объекты разных группы должны быть как можно более отличны.

CHAMELEON - это агломеративный иерархический алгоритм кластеризации, ключевой особенностью которого является то, что он учитывает и взаимную связность, и сходство при определении наиболее похожей пары подкластеров, основываясь на динамической модели. Это означает, что в процессе кластеризации два кластера объединяются, только если их относительная взаимная связность и относительное взаимное сходство являются высокими по отношению к внутренней взаимосвязанности кластеров и близости элементов внутри кластеров. Кроме того, CHAMELEON использует подход для моделирования степени взаимосвязанности и близости между каждой парой кластеров, который учитывает внутренние характеристики самих кластеров. Таким образом, он может автоматически адаптироваться к внутренним характеристикам объединяемых кластеров.

CHAMELEON находит кластеры в наборе данных с помощью трехфазного алгоритма. На первой фазе происходит построение графа, путём добавления рёбер по принципу k ближайших соседей. На второй фазе CHAMELEON группирует полученные элементы в множество относительно небольших подграфов. Во время третьей фазы применяется агломеративный иерархический алгоритм кластеризации, с помощью которого находятся естесственные кластеры путем многократного объединения подграфов, полученных на прошлом этапе.

[[File:Chameleon.png|1000px|thumb|center|Рисунок 1. Общая структура алгоритма CHAMELEON]]

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

''Исходные данные'':

* Множество из n точек <math>V= {v_{ij}}</math> в метрическом пространстве, которое задано симметрической матрицей расстояний <math>A</math> размера <math>n\times n</math>.
* <math>k</math> - количество ближайших соседей для вершин, <math>k \in N, k \leq n</math>.
* <math>l</math> - наименьшее число вершин, которое может содержать наибольший подграф на 2-м этапе, <math>l \in N, l \leq n</math>.

''Обозначения'':

* <math>G = (V, E)</math> - граф, полученный путём соединения каждой точки с её <math>k</math> ближайшими соседями.

* <math>K= \{K_{i}\}</math> - разбиение множества <math>V</math> на набор попарно непересекающихся связных подмножеств, полученное в результате выполнения второй фазы алгоритма.

* <math>G_{2} = (K, E_{2})</math> - взвешенный граф, вершинами которого являются получившиеся подграфы, а ребрами - количество ребер исходного графа, соединяющих соответствующие подграфы.

* <math>C = \{C_{i}\}</math> - итоговое разбиение множества вершин графа <math>G_{2}</math> на набор кластеров.

''Вспомогательные понятия''

*<math>EC_{(C_{i},C_{j})}</math> - абсолютная взаимная связность пары кластеров <math>C_{i}, C{j}</math>. Определяется как сумма весов ребер, соединяющих вершины, принадлежащие <math>C{i}</math> c вершинами из <math>C{j}</math>. Внутренняя связность <math>EC_{(C_{i},C_{i})}</math> вычисляется как сумма ребер, входящих в разделитель, разбивающий <math>C{i}</math> на два равных подграфа.

*<math>RI_{(C_{i},C_{j})} = \frac{|EC_{(C_{i},C_{j})}|}{(|EC_{C_{i}}|+|EC_{C_{j}}|)/2}</math> - относительная взаимная связность пары кластеров <math>C_{i}, C{j}</math>

*<math>S_{EC_{(C_{i},C_{j})}}</math> - абсолютное взаимное сходство пары кластеров <math>C_{i}, C{j}</math>. Подсчитывается как среднее сходство между соединенными вершинами, принадлежащими <math>C{i}</math> и <math>C{j}</math> соответственно. Соединения обусловлены разбиением общего графа, полученного на первом этапе алгоритма.

*<math> RC_{(C_{i},C_{j})}= \frac{S_{EC_{(C_{i},C_{j})}}}{\frac{|C_{i}|}{|C_{i}+C_{j}|}*S_{EC_{(C_{i})}}+\frac{|C_{i}|}{|C_{i}+C_{j}|}*S_{EC_{(C_{j})}}}</math> - относительное взаимное сходство пары кластеров <math>C_{i}, C{j}</math>. Определяется как абсолютное сходство между этой парой кластеров, нормализованное с учетом их внутреннего сходства.

'''Первый этап'''

На первом этапе, согласно графо-ориентированному подходу, происходит построение графа <math>G = (V, E)</math> на матрице сходства объектов по принципу k ближайших соседей. Две вершины такого графа соединяет ребро, если объект, соответствующий любой из этих вершин попадает в число k наиболее близких объектов для объекта, соответствующего другой вершине из данной пары.
[[Файл:Снимок chameleon 2.png|thumb|Рисунок 2. Объекты в пространстве - слева, граф по принципу 1-го ближайшего соседа - по центру, граф по принципу 3-х ближайших соседей - справа ]]

'''Второй этап'''

Алгоритм разделяет полученный граф на множество сравнительно малых подграфов <math>K= \{K_{i}\}</math>. Разделение происходит последовательно. На каждом шаге выбирается подграф, содержащий наибольшее число вершин. Этот граф разделяется на два подграфа так, что разделитель ребер графа минимален и каждый из получаемых подграфов содержит не менее 25 % вершин исходного графа. Процесс разделения останавливается, когда наибольший подграф содержит меньше некоторого заданного числа вершин. Обычно величина этого параметра задается равной значению от 1 до 5 % от числа объектов. Полученное множество связных графов считается множеством начальных кластеров, на котором требуется провести последовательное иерархическое объединение.

'''Третий этап'''

Третий этап заключается в итеративном преобразовании множества подграфов <math>K= \{K_{i}\}</math> в множество кластеров <math>C = \{C_{i}\}</math>. Алгоритм осуществляет агломеративную иерархическую кластеризацию на основании показателей <math>EC_{(C_{i},C_{j})}</math>, <math>S_{EC_{(C_{i},C_{j})}}</math>, <math>RI_{(C_{i},C_{j})} </math>, <math> RC_{(C_{i},C_{j})}</math>. Существует две стратегии анализа показателей сходства. Первая подразумевает наличие некоторых пороговых значений <math>T_{RI}</math> и <math>T_{RC}</math>. В соответствии с этой стратегией, алгоритм для каждого кластера <math>C_{i}</math> проверяет, отвечают ли смежные (наиболее близкие) ему кластеры условиям:

*<math>RI_{(C_{i},C_{j})} \geqslant T_{RI}</math>

*<math>RC_{(C_{i},C_{j})} \geqslant T_{RC}</math>

Если более одного смежного кластера отвечает этим условиям, то алгоритм выбирает для объединения наиболее связный кластер (граф), то есть такой кластер <math>C_{j}</math>, с которым у кластера <math>C_{i}</math> получается наибольшая абсолютная взаимная связность. По завершению прохода по всем кластерам, созданные таким образом пары объединяются. Параметры <math>T_{RI}</math> и <math>T_{RC}</math> могут использоваться для изменения характеристик получаемых кластеров.

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

<math>RI_{(C_{i},C_{j})}*RC_{(C_{i},C_{j})}^\alpha</math>,

где <math>\alpha</math> выбирается пользователем. Если <math>\alpha > 1 </math>, то алгоритм придает большее значение относительному взаимному сходству, а если <math>\alpha < 1 </math>, то большее значение имеет относительная взаимная связность.

''Вычисляемые данные'':

<math>U = (u_1, u_2, ..., u_n)</math> - n-мерный вектор, где <math>u_i \in N_{[C]}</math> - порядковый номер кластера, к которому принадлежит вершина i исходного множества V.

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

Алгоритм имеет три вычислительных ядра, по одному на каждый этап.

На первом этапе вычислительным ядром является процесс нахождения <math>k</math> ближайших соседей для каждой вершины, который заключается в анализе матрицы расстояний.

На втором этапе вычислительным ядром является процесс поиска подходящего разбиения очередного подграфа на два графа с минимизацией разделителя ребер графа.

На третьем этапе вычислительным ядром является расчет величин <math>EC_{(C_{i},C_{j})}</math>, <math>S_{EC_{(C_{i},C_{j})}}</math>, <math>RI_{(C_{i},C_{j})} </math>, <math> RC_{(C_{i},C_{j})}</math> для каждой пары смежных кластеров.

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

Как уже рассказывалось ранее, алгоритм включает в себя три основных этапа, каждый из которых, по сути, является отдельным алгоритмом. Этапы выполняются последовательно относительно друг друга.

Макрооперация на первом этапе - процедура нахождения <math>k</math> ближайших соседей, на втором - процедура разбиения наибольшего подграфа на два графа, на третьем - процедура вычисления показателей сходства, на основе которых принимается решение о слиянии подграфов в кластер.

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

'''Первый этап'''
<source lang="cpp">
int n; //количество вершин
int k; //количество соседей
int A[n][n] //матрица расстояний
int D[k] //массив вершин-соседей
int E[n][n] //матрица ребер графа <math>G_{2} = (K, E_{2})</math>
for i=1 to n-1 do
{
for j=i+1 to n do
{
//заполняем массив вершин-соседей вставляя новые вершины, если они ближе, чем самая далекая из массива.
}
for j=0 to k do
{
//для каждой вершины соседа заполняем соответствующую ячейку из матрицы E[n][n] единицей
}

}
</source>

'''Второй этап'''

1. Все связные подграфы в отсортированном порядке помещаются в список;
2. Берем наибольший элемент списка, вычисляем количество его вершин. Если число вершин > l, то идем в пункт 3. Иначе в пункт 5;
3. Разбиваем подграф на два подграфа таким образом, чтобы разделитель ребер графа был минимален и каждый из получаемых подграфов содержал не менее 25 % вершин исходного графа;
4. Добавляем полученные элементы в список подграфов таким образом, чтобы список оставался отсортированным. Идем в пункт 2;
5. Нашли искомое множество подграфов math>K = \{K_{i}\}</math>;
6. Создаем и заполняем матрицу матрицу расстояний для графа <math>G_{2} = (K, E_{2})</math>. Получаем искомый набор рёбер <math>E_{2}</math>.

'''Третий этап'''

1. Заводим два массива: а) массив кластеров C, полученных на предыдущем этапе, б) массив объединений кластеров F, которые мы будем получать на этом этапе;
2. Берем следующий кластер <math>C_{i}</math> (на первом шаге - первый). Если все кластеры просмотрены, идем в пункт 6;
3. Берем следующий кластер <math>C_{j}, i<>j</math>. Если все кластеры просмотрены, то идем в пункт 2;
4. Проверяем смежность <math>C_{i}</math> и <math>C_{j}</math>. Если не смежны, то возвращаемся в пункт 3. Если смежны, идем в пункт 5;
5. Рассчитываем показатели <math>RI_{(C_{i},C_{j})}</math> и <math> RC_{(C_{i},C_{j})}</math>. Проверяем, удовлетворяют ли найденные значения условиям:
*<math>RI_{(C_{i},C_{j})} \geqslant T_{RI}</math>
*<math>RC_{(C_{i},C_{j})} \geqslant T_{RC}</math>
Если нет, то идем в пункт 3. Иначе если смежность пары кластеров выше, чем у предыдущих найденных, то <math>F_{i}=j</math>. Идем в пункт 3;
6. Если в списке F есть хотя бы одна пара кластеров для слияния, то выполняем слияние, обновляем массив кластеров и массив объединений кластеров. Идем в пункт 2.

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

1) Для построения графа на основе метода k ближайших соседей для n вершин требуется <math>O(n log(n))</math> операций [3]; для наборов данных большой размерности эта величина составляет <math>O(n^2)</math> операций [4];

2) Для выделения множества сравнительно малых связных подграфов требуется <math>nm</math> операций, где <math>m</math> - количество подграфов, полученных на втором этапе алгоритма;

3) Формирование набора кластеров, на основе множества подграфов, полученных на предыдущем этапе, требует <math>m^2log(m)</math> операций.

Итого, для n вершин получаем последовательную сложность <math>O(n log(n)+nm+m^2log(m))</math>.

== Информационный граф ==
[[File:СК.png]]

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

Первый этап работы алгоритма можно распределить между <math>n</math> процессами. На вход каждому процессу подается своя вершина, далее происходит процедура поиска <math>k</math> ближайших соседей. Параллельная сложность составляет <math>O(n)</math>.

Второй и третий этапы можно распараллелить частично.

Второй этап распараллеливается путем подачи на вход свободному процессу очередного подграфа для разделения. Число итераций оценивается в <math>O(n log(n))</math>.

Третий этап делится на расчет показателей схожести и соединение подграфов в кластеры. Процесс расчета показателей можно распараллелить, подавая каждому процессу на вход пару подграфов. Сложность этого процесса оценивается как <math>m log(m)</math>. Соединение подграфов в кластеры выполняется последовательно, сложность процесса составляет <math>m^2 log(m)</math>

Таким образом получаем общую параллельную сложность алгоритма: <math>O(n+ n log(n) + m^2 log (m) + m log(m))</math>

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

1. Симметрическая матрица <math>A</math> расстояний между элементами данных размера <math>n\times n</math> с нулями на главной диагонали (<math>a_{ii}= 0, i = 1, \ldots, N</math>).

2. <math>k</math> - количество ближайших соседей для вершин (рекомендуемое значение <math>k</math> от 5 до 20 в зависимости от количества анализируемых объектов).

3. <math>l</math> - наименьшее число вершин, которое может содержать наибольший подкластер на 2-м этапе . Величина этого параметра варьируется от 1 до 5 % от общего числа объектов.

'''Объём входных данных'''

<math>\frac{n (n - 1)}{2}</math> (в силу симметричности и нулевой главной диагонали достаточно хранить только над/поддиагональные элементы).

'''Выходные данные'''

Вектор из <math>n</math> чисел <math>u_{1}, u_{2}, \ldots, u_{N}</math>, где <math>u_{i}</math> - целое число, соответствующее кластеру <math>i</math>-го объекта.

'''Объём выходных данных'''

<math>n</math>

== Свойства алгоритма ==
Соотношение последовательной и параллельной сложности на первом этапе является ''линейным'' для больших наборов данных и логарифмическим для n вершин. На втором этапе сложно оценить это соотношение - оно сильно зависит от параметров <math>k</math> и <math>l</math>. На третьем этапе соотношение равно <math>O(1)</math>

Алгоритм является недетерминированным. Хотя 1-й этап детерминирован, на 2-ом этапе могут быть найдены различные разбиения на подграфы, что повлияет и на итоговый результат работы алгоритма.

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

см. позднее

== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Последовательная реализация алгоритма доступна по ссылке [5].

CHAMELEON можно реализовать с использованием графовых библиотек METIS [6], hMETIS [7] и RANN [8].

Существует исследование, связанное с реализацией CHAMELEON посредством технологии OpenMP, с которым можно ознакомиться здесь [9].

Параллельных реализаций алгоритма CHAMELEON не найдено.

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

[2] http://studopedia.ru/7_41934_algoritm-dinamicheskoy-ierarhicheskoy-klasterizatsii-CHAMELEON.html

[3] J.H. Friedman, J.L. Bentley, and R.A. Finkel. An algorithm for ﬁnding best matches in logarithmic expected time. ACM Transactions on Mathematical Software, 3:209–226, 1977.

[4] S. Berchtold, C. Bohm, D. Keim, and H.-P. Kriegel. Cost model for nearest neighbor search in high dimensional data space. In Proc. of Symposium on Principles of Database Systems, Tucson, Arizona, 1997.

[5] http://www.codeforge.com/article/192925

[6] http://glaros.dtc.umn.edu/gkhome/metis/metis/overview

[7] http://glaros.dtc.umn.edu/gkhome/metis/hmetis/overview

[8] https://cran.r-project.org/web/packages/RANN/index.html

[9] http://research.ijcaonline.org/volume79/number8/pxc3891600.pdf

Участник:ЕкатеринаКозырева/Алгоритм динамической иерархической кластеризации CHAMELEON

2016-10-31T18:43:53Z

ЕкатеринаКозырева: /* Математическое описание алгоритма */

{{algorithm
| name = Алгоритм динамической иерархической кластеризации CHAMELEON
| serial_complexity = <math>O(nm + n log n + m^2 log m)</math>
| input_data = <math>\frac{n (n - 1)}{2}</math>
| output_data = <math>n</math>
| pf_height = <math>O(n+ n log(n) + m^2 log (m) + m log(m))</math>
| pf_width = <math>O(n)</math>
}}

Автор описания [[Участник:ЕкатеринаКозырева|Е.А.Козырева]]
= Свойства и структура алгоритмов =

== Общее описание алгоритма ==
Алгоритм CHAMELEON был предложен в 1999 году тремя учеными из университета Миннесоты – George Karypis, Eui-Hong (Sam) Han и Vipin Kumar<ref>George Karypis, Eui-Hong (Sam) Han и Vipin Kumar, «Chameleon: Hierarchical Clustering Using Dynamic Modeling», 1999.</ref>.

Предназначен для решения задач кластеризации. Кластеризация (или кластерный анализ) — это задача разбиения множества объектов на группы, называемые кластерами. Внутри каждой группы должны оказаться «похожие» объекты, а объекты разных группы должны быть как можно более отличны.

CHAMELEON - это агломеративный иерархический алгоритм кластеризации, ключевой особенностью которого является то, что он учитывает и взаимную связность, и сходство при определении наиболее похожей пары подкластеров, основываясь на динамической модели. Это означает, что в процессе кластеризации два кластера объединяются, только если их относительная взаимная связность и относительное взаимное сходство являются высокими по отношению к внутренней взаимосвязанности кластеров и близости элементов внутри кластеров. Кроме того, CHAMELEON использует подход для моделирования степени взаимосвязанности и близости между каждой парой кластеров, который учитывает внутренние характеристики самих кластеров. Таким образом, он может автоматически адаптироваться к внутренним характеристикам объединяемых кластеров.

CHAMELEON находит кластеры в наборе данных с помощью трехфазного алгоритма. На первой фазе происходит построение графа, путём добавления рёбер по принципу k ближайших соседей. На второй фазе CHAMELEON группирует полученные элементы в множество относительно небольших подграфов. Во время третьей фазы применяется агломеративный иерархический алгоритм кластеризации, с помощью которого находятся естесственные кластеры путем многократного объединения подграфов, полученных на прошлом этапе.

[[File:Chameleon.png|1000px|thumb|center|Рисунок 1. Общая структура алгоритма CHAMELEON]]

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

''Исходные данные'':

* Множество из n точек <math>V= {v_{ij}}</math> в метрическом пространстве, которое задано симметрической матрицей расстояний <math>A</math> размера <math>n\times n</math>.
* <math>k</math> - количество ближайших соседей для вершин, <math>k \in N, k \leq n</math>.
* <math>l</math> - наименьшее число вершин, которое может содержать наибольший подграф на 2-м этапе, <math>l \in N, l \leq n</math>.

''Обозначения'':

* <math>G = (V, E)</math> - граф, полученный путём соединения каждой точки с её <math>k</math> ближайшими соседями.

* <math>K= \{K_{i}\}</math> - разбиение множества <math>V</math> на набор попарно непересекающихся связных подмножеств, полученное в результате выполнения второй фазы алгоритма.

* <math>G_{2} = (K, E_{2})</math> - взвешенный граф, вершинами которого являются получившиеся подграфы, а ребрами - количество ребер исходного графа, соединяющих соответствующие подграфы.

* <math>C = \{C_{i}\}</math> - итоговое разбиение множества вершин графа <math>G_{2}</math> на набор кластеров.

''Вспомогательные понятия''

*<math>EC_{(C_{i},C_{j})}</math> - абсолютная взаимная связность пары кластеров <math>C_{i}, C{j}</math>. Определяется как сумма весов ребер, соединяющих вершины, принадлежащие <math>C{i}</math> c вершинами из <math>C{j}</math>. Внутренняя связность <math>EC_{(C_{i},C_{i})}</math> вычисляется как сумма ребер, входящих в разделитель, разбивающий <math>C{i}</math> на два равных подграфа.

*<math>RI_{(C_{i},C_{j})} = \frac{|EC_{(C_{i},C_{j})}|}{(|EC_{C_{i}}|+|EC_{C_{j}}|)/2}</math> - относительная взаимная связность пары кластеров <math>C_{i}, C{j}</math>

*<math>S_{EC_{(C_{i},C_{j})}}</math> - абсолютное взаимное сходство пары кластеров <math>C_{i}, C{j}</math>. Подсчитывается как среднее сходство между соединенными вершинами, принадлежащими <math>C{i}</math> и <math>C{j}</math> соответственно. Соединения обусловлены разбиением общего графа, полученного на первом этапе алгоритма.

*<math> RC_{(C_{i},C_{j})}= \frac{S_{EC_{(C_{i},C_{j})}}}{\frac{|C_{i}|}{|C_{i}+C_{j}|}*S_{EC_{(C_{i})}}+\frac{|C_{i}|}{|C_{i}+C_{j}|}*S_{EC_{(C_{j})}}}</math> - относительное взаимное сходство пары кластеров <math>C_{i}, C{j}</math>. Определяется как абсолютное сходство между этой парой кластеров, нормализованное с учетом их внутреннего сходства.

'''Первый этап'''

На первом этапе, согласно графо-ориентированному подходу, происходит построение графа <math>G = (V, E)</math> на матрице сходства объектов по принципу k ближайших соседей. Две вершины такого графа соединяет ребро, если объект, соответствующий любой из этих вершин попадает в число k наиболее близких объектов для объекта, соответствующего другой вершине из данной пары.
[[Файл:Снимок chameleon 2.png|Рисунок 2. Объекты в пространстве - слева, граф по принципу 1-го ближайшего соседа - по центру, граф по принципу 3-х ближайших соседей - справа ]]

'''Второй этап'''

Алгоритм разделяет полученный граф на множество сравнительно малых подграфов <math>K= \{K_{i}\}</math>. Разделение происходит последовательно. На каждом шаге выбирается подграф, содержащий наибольшее число вершин. Этот граф разделяется на два подграфа так, что разделитель ребер графа минимален и каждый из получаемых подграфов содержит не менее 25 % вершин исходного графа. Процесс разделения останавливается, когда наибольший подграф содержит меньше некоторого заданного числа вершин. Обычно величина этого параметра задается равной значению от 1 до 5 % от числа объектов. Полученное множество связных графов считается множеством начальных кластеров, на котором требуется провести последовательное иерархическое объединение.

'''Третий этап'''

Третий этап заключается в итеративном преобразовании множества подграфов <math>K= \{K_{i}\}</math> в множество кластеров <math>C = \{C_{i}\}</math>. Алгоритм осуществляет агломеративную иерархическую кластеризацию на основании показателей <math>EC_{(C_{i},C_{j})}</math>, <math>S_{EC_{(C_{i},C_{j})}}</math>, <math>RI_{(C_{i},C_{j})} </math>, <math> RC_{(C_{i},C_{j})}</math>. Существует две стратегии анализа показателей сходства. Первая подразумевает наличие некоторых пороговых значений <math>T_{RI}</math> и <math>T_{RC}</math>. В соответствии с этой стратегией, алгоритм для каждого кластера <math>C_{i}</math> проверяет, отвечают ли смежные (наиболее близкие) ему кластеры условиям:

*<math>RI_{(C_{i},C_{j})} \geqslant T_{RI}</math>

*<math>RC_{(C_{i},C_{j})} \geqslant T_{RC}</math>

Если более одного смежного кластера отвечает этим условиям, то алгоритм выбирает для объединения наиболее связный кластер (граф), то есть такой кластер <math>C_{j}</math>, с которым у кластера <math>C_{i}</math> получается наибольшая абсолютная взаимная связность. По завершению прохода по всем кластерам, созданные таким образом пары объединяются. Параметры <math>T_{RI}</math> и <math>T_{RC}</math> могут использоваться для изменения характеристик получаемых кластеров.

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

<math>RI_{(C_{i},C_{j})}*RC_{(C_{i},C_{j})}^\alpha</math>,

где <math>\alpha</math> выбирается пользователем. Если <math>\alpha > 1 </math>, то алгоритм придает большее значение относительному взаимному сходству, а если <math>\alpha < 1 </math>, то большее значение имеет относительная взаимная связность.

''Вычисляемые данные'':

<math>U = (u_1, u_2, ..., u_n)</math> - n-мерный вектор, где <math>u_i \in N_{[C]}</math> - порядковый номер кластера, к которому принадлежит вершина i исходного множества V.

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

Алгоритм имеет три вычислительных ядра, по одному на каждый этап.

На первом этапе вычислительным ядром является процесс нахождения <math>k</math> ближайших соседей для каждой вершины, который заключается в анализе матрицы расстояний.

На втором этапе вычислительным ядром является процесс поиска подходящего разбиения очередного подграфа на два графа с минимизацией разделителя ребер графа.

На третьем этапе вычислительным ядром является расчет величин <math>EC_{(C_{i},C_{j})}</math>, <math>S_{EC_{(C_{i},C_{j})}}</math>, <math>RI_{(C_{i},C_{j})} </math>, <math> RC_{(C_{i},C_{j})}</math> для каждой пары смежных кластеров.

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

Как уже рассказывалось ранее, алгоритм включает в себя три основных этапа, каждый из которых, по сути, является отдельным алгоритмом. Этапы выполняются последовательно относительно друг друга.

Макрооперация на первом этапе - процедура нахождения <math>k</math> ближайших соседей, на втором - процедура разбиения наибольшего подграфа на два графа, на третьем - процедура вычисления показателей сходства, на основе которых принимается решение о слиянии подграфов в кластер.

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

'''Первый этап'''
<source lang="cpp">
int n; //количество вершин
int k; //количество соседей
int A[n][n] //матрица расстояний
int D[k] //массив вершин-соседей
int E[n][n] //матрица ребер графа <math>G_{2} = (K, E_{2})</math>
for i=1 to n-1 do
{
for j=i+1 to n do
{
//заполняем массив вершин-соседей вставляя новые вершины, если они ближе, чем самая далекая из массива.
}
for j=0 to k do
{
//для каждой вершины соседа заполняем соответствующую ячейку из матрицы E[n][n] единицей
}

}
</source>

'''Второй этап'''

1. Все связные подграфы в отсортированном порядке помещаются в список;
2. Берем наибольший элемент списка, вычисляем количество его вершин. Если число вершин > l, то идем в пункт 3. Иначе в пункт 5;
3. Разбиваем подграф на два подграфа таким образом, чтобы разделитель ребер графа был минимален и каждый из получаемых подграфов содержал не менее 25 % вершин исходного графа;
4. Добавляем полученные элементы в список подграфов таким образом, чтобы список оставался отсортированным. Идем в пункт 2;
5. Нашли искомое множество подграфов math>K = \{K_{i}\}</math>;
6. Создаем и заполняем матрицу матрицу расстояний для графа <math>G_{2} = (K, E_{2})</math>. Получаем искомый набор рёбер <math>E_{2}</math>.

'''Третий этап'''

1. Заводим два массива: а) массив кластеров C, полученных на предыдущем этапе, б) массив объединений кластеров F, которые мы будем получать на этом этапе;
2. Берем следующий кластер <math>C_{i}</math> (на первом шаге - первый). Если все кластеры просмотрены, идем в пункт 6;
3. Берем следующий кластер <math>C_{j}, i<>j</math>. Если все кластеры просмотрены, то идем в пункт 2;
4. Проверяем смежность <math>C_{i}</math> и <math>C_{j}</math>. Если не смежны, то возвращаемся в пункт 3. Если смежны, идем в пункт 5;
5. Рассчитываем показатели <math>RI_{(C_{i},C_{j})}</math> и <math> RC_{(C_{i},C_{j})}</math>. Проверяем, удовлетворяют ли найденные значения условиям:
*<math>RI_{(C_{i},C_{j})} \geqslant T_{RI}</math>
*<math>RC_{(C_{i},C_{j})} \geqslant T_{RC}</math>
Если нет, то идем в пункт 3. Иначе если смежность пары кластеров выше, чем у предыдущих найденных, то <math>F_{i}=j</math>. Идем в пункт 3;
6. Если в списке F есть хотя бы одна пара кластеров для слияния, то выполняем слияние, обновляем массив кластеров и массив объединений кластеров. Идем в пункт 2.

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

1) Для построения графа на основе метода k ближайших соседей для n вершин требуется <math>O(n log(n))</math> операций [3]; для наборов данных большой размерности эта величина составляет <math>O(n^2)</math> операций [4];

2) Для выделения множества сравнительно малых связных подграфов требуется <math>nm</math> операций, где <math>m</math> - количество подграфов, полученных на втором этапе алгоритма;

3) Формирование набора кластеров, на основе множества подграфов, полученных на предыдущем этапе, требует <math>m^2log(m)</math> операций.

Итого, для n вершин получаем последовательную сложность <math>O(n log(n)+nm+m^2log(m))</math>.

== Информационный граф ==
[[File:СК.png]]

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

Первый этап работы алгоритма можно распределить между <math>n</math> процессами. На вход каждому процессу подается своя вершина, далее происходит процедура поиска <math>k</math> ближайших соседей. Параллельная сложность составляет <math>O(n)</math>.

Второй и третий этапы можно распараллелить частично.

Второй этап распараллеливается путем подачи на вход свободному процессу очередного подграфа для разделения. Число итераций оценивается в <math>O(n log(n))</math>.

Третий этап делится на расчет показателей схожести и соединение подграфов в кластеры. Процесс расчета показателей можно распараллелить, подавая каждому процессу на вход пару подграфов. Сложность этого процесса оценивается как <math>m log(m)</math>. Соединение подграфов в кластеры выполняется последовательно, сложность процесса составляет <math>m^2 log(m)</math>

Таким образом получаем общую параллельную сложность алгоритма: <math>O(n+ n log(n) + m^2 log (m) + m log(m))</math>

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

1. Симметрическая матрица <math>A</math> расстояний между элементами данных размера <math>n\times n</math> с нулями на главной диагонали (<math>a_{ii}= 0, i = 1, \ldots, N</math>).

2. <math>k</math> - количество ближайших соседей для вершин (рекомендуемое значение <math>k</math> от 5 до 20 в зависимости от количества анализируемых объектов).

3. <math>l</math> - наименьшее число вершин, которое может содержать наибольший подкластер на 2-м этапе . Величина этого параметра варьируется от 1 до 5 % от общего числа объектов.

'''Объём входных данных'''

<math>\frac{n (n - 1)}{2}</math> (в силу симметричности и нулевой главной диагонали достаточно хранить только над/поддиагональные элементы).

'''Выходные данные'''

Вектор из <math>n</math> чисел <math>u_{1}, u_{2}, \ldots, u_{N}</math>, где <math>u_{i}</math> - целое число, соответствующее кластеру <math>i</math>-го объекта.

'''Объём выходных данных'''

<math>n</math>

== Свойства алгоритма ==
Соотношение последовательной и параллельной сложности на первом этапе является ''линейным'' для больших наборов данных и логарифмическим для n вершин. На втором этапе сложно оценить это соотношение - оно сильно зависит от параметров <math>k</math> и <math>l</math>. На третьем этапе соотношение равно <math>O(1)</math>

Алгоритм является недетерминированным. Хотя 1-й этап детерминирован, на 2-ом этапе могут быть найдены различные разбиения на подграфы, что повлияет и на итоговый результат работы алгоритма.

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

см. позднее

== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Последовательная реализация алгоритма доступна по ссылке [5].

CHAMELEON можно реализовать с использованием графовых библиотек METIS [6], hMETIS [7] и RANN [8].

Существует исследование, связанное с реализацией CHAMELEON посредством технологии OpenMP, с которым можно ознакомиться здесь [9].

Параллельных реализаций алгоритма CHAMELEON не найдено.

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

[2] http://studopedia.ru/7_41934_algoritm-dinamicheskoy-ierarhicheskoy-klasterizatsii-CHAMELEON.html

[3] J.H. Friedman, J.L. Bentley, and R.A. Finkel. An algorithm for ﬁnding best matches in logarithmic expected time. ACM Transactions on Mathematical Software, 3:209–226, 1977.

[4] S. Berchtold, C. Bohm, D. Keim, and H.-P. Kriegel. Cost model for nearest neighbor search in high dimensional data space. In Proc. of Symposium on Principles of Database Systems, Tucson, Arizona, 1997.

[5] http://www.codeforge.com/article/192925

[6] http://glaros.dtc.umn.edu/gkhome/metis/metis/overview

[7] http://glaros.dtc.umn.edu/gkhome/metis/hmetis/overview

[8] https://cran.r-project.org/web/packages/RANN/index.html

[9] http://research.ijcaonline.org/volume79/number8/pxc3891600.pdf

Участник:ЕкатеринаКозырева/Алгоритм динамической иерархической кластеризации CHAMELEON

2016-10-31T18:43:23Z

ЕкатеринаКозырева: /* Математическое описание алгоритма */

{{algorithm
| name = Алгоритм динамической иерархической кластеризации CHAMELEON
| serial_complexity = <math>O(nm + n log n + m^2 log m)</math>
| input_data = <math>\frac{n (n - 1)}{2}</math>
| output_data = <math>n</math>
| pf_height = <math>O(n+ n log(n) + m^2 log (m) + m log(m))</math>
| pf_width = <math>O(n)</math>
}}

Автор описания [[Участник:ЕкатеринаКозырева|Е.А.Козырева]]
= Свойства и структура алгоритмов =

== Общее описание алгоритма ==
Алгоритм CHAMELEON был предложен в 1999 году тремя учеными из университета Миннесоты – George Karypis, Eui-Hong (Sam) Han и Vipin Kumar<ref>George Karypis, Eui-Hong (Sam) Han и Vipin Kumar, «Chameleon: Hierarchical Clustering Using Dynamic Modeling», 1999.</ref>.

Предназначен для решения задач кластеризации. Кластеризация (или кластерный анализ) — это задача разбиения множества объектов на группы, называемые кластерами. Внутри каждой группы должны оказаться «похожие» объекты, а объекты разных группы должны быть как можно более отличны.

CHAMELEON - это агломеративный иерархический алгоритм кластеризации, ключевой особенностью которого является то, что он учитывает и взаимную связность, и сходство при определении наиболее похожей пары подкластеров, основываясь на динамической модели. Это означает, что в процессе кластеризации два кластера объединяются, только если их относительная взаимная связность и относительное взаимное сходство являются высокими по отношению к внутренней взаимосвязанности кластеров и близости элементов внутри кластеров. Кроме того, CHAMELEON использует подход для моделирования степени взаимосвязанности и близости между каждой парой кластеров, который учитывает внутренние характеристики самих кластеров. Таким образом, он может автоматически адаптироваться к внутренним характеристикам объединяемых кластеров.

CHAMELEON находит кластеры в наборе данных с помощью трехфазного алгоритма. На первой фазе происходит построение графа, путём добавления рёбер по принципу k ближайших соседей. На второй фазе CHAMELEON группирует полученные элементы в множество относительно небольших подграфов. Во время третьей фазы применяется агломеративный иерархический алгоритм кластеризации, с помощью которого находятся естесственные кластеры путем многократного объединения подграфов, полученных на прошлом этапе.

[[File:Chameleon.png|1000px|thumb|center|Рисунок 1. Общая структура алгоритма CHAMELEON]]

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

''Исходные данные'':

* Множество из n точек <math>V= {v_{ij}}</math> в метрическом пространстве, которое задано симметрической матрицей расстояний <math>A</math> размера <math>n\times n</math>.
* <math>k</math> - количество ближайших соседей для вершин, <math>k \in N, k \leq n</math>.
* <math>l</math> - наименьшее число вершин, которое может содержать наибольший подграф на 2-м этапе, <math>l \in N, l \leq n</math>.

''Обозначения'':

* <math>G = (V, E)</math> - граф, полученный путём соединения каждой точки с её <math>k</math> ближайшими соседями.

* <math>K= \{K_{i}\}</math> - разбиение множества <math>V</math> на набор попарно непересекающихся связных подмножеств, полученное в результате выполнения второй фазы алгоритма.

* <math>G_{2} = (K, E_{2})</math> - взвешенный граф, вершинами которого являются получившиеся подграфы, а ребрами - количество ребер исходного графа, соединяющих соответствующие подграфы.

* <math>C = \{C_{i}\}</math> - итоговое разбиение множества вершин графа <math>G_{2}</math> на набор кластеров.

''Вспомогательные понятия''

*<math>EC_{(C_{i},C_{j})}</math> - абсолютная взаимная связность пары кластеров <math>C_{i}, C{j}</math>. Определяется как сумма весов ребер, соединяющих вершины, принадлежащие <math>C{i}</math> c вершинами из <math>C{j}</math>. Внутренняя связность <math>EC_{(C_{i},C_{i})}</math> вычисляется как сумма ребер, входящих в разделитель, разбивающий <math>C{i}</math> на два равных подграфа.

*<math>RI_{(C_{i},C_{j})} = \frac{|EC_{(C_{i},C_{j})}|}{(|EC_{C_{i}}|+|EC_{C_{j}}|)/2}</math> - относительная взаимная связность пары кластеров <math>C_{i}, C{j}</math>

*<math>S_{EC_{(C_{i},C_{j})}}</math> - абсолютное взаимное сходство пары кластеров <math>C_{i}, C{j}</math>. Подсчитывается как среднее сходство между соединенными вершинами, принадлежащими <math>C{i}</math> и <math>C{j}</math> соответственно. Соединения обусловлены разбиением общего графа, полученного на первом этапе алгоритма.

*<math> RC_{(C_{i},C_{j})}= \frac{S_{EC_{(C_{i},C_{j})}}}{\frac{|C_{i}|}{|C_{i}+C_{j}|}*S_{EC_{(C_{i})}}+\frac{|C_{i}|}{|C_{i}+C_{j}|}*S_{EC_{(C_{j})}}}</math> - относительное взаимное сходство пары кластеров <math>C_{i}, C{j}</math>. Определяется как абсолютное сходство между этой парой кластеров, нормализованное с учетом их внутреннего сходства.

'''Первый этап'''

На первом этапе, согласно графо-ориентированному подходу, происходит построение графа <math>G = (V, E)</math> на матрице сходства объектов по принципу k ближайших соседей. Две вершины такого графа соединяет ребро, если объект, соответствующий любой из этих вершин попадает в число k наиболее близких объектов для объекта, соответствующего другой вершине из данной пары.
[[Файл:Снимок chameleon 2.png|1000px|thumb|Рисунок 2. Объекты в пространстве - слева, граф по принципу 1-го ближайшего соседа - по центру, граф по принципу 3-х ближайших соседей - справа ]]

'''Второй этап'''

Алгоритм разделяет полученный граф на множество сравнительно малых подграфов <math>K= \{K_{i}\}</math>. Разделение происходит последовательно. На каждом шаге выбирается подграф, содержащий наибольшее число вершин. Этот граф разделяется на два подграфа так, что разделитель ребер графа минимален и каждый из получаемых подграфов содержит не менее 25 % вершин исходного графа. Процесс разделения останавливается, когда наибольший подграф содержит меньше некоторого заданного числа вершин. Обычно величина этого параметра задается равной значению от 1 до 5 % от числа объектов. Полученное множество связных графов считается множеством начальных кластеров, на котором требуется провести последовательное иерархическое объединение.

'''Третий этап'''

Третий этап заключается в итеративном преобразовании множества подграфов <math>K= \{K_{i}\}</math> в множество кластеров <math>C = \{C_{i}\}</math>. Алгоритм осуществляет агломеративную иерархическую кластеризацию на основании показателей <math>EC_{(C_{i},C_{j})}</math>, <math>S_{EC_{(C_{i},C_{j})}}</math>, <math>RI_{(C_{i},C_{j})} </math>, <math> RC_{(C_{i},C_{j})}</math>. Существует две стратегии анализа показателей сходства. Первая подразумевает наличие некоторых пороговых значений <math>T_{RI}</math> и <math>T_{RC}</math>. В соответствии с этой стратегией, алгоритм для каждого кластера <math>C_{i}</math> проверяет, отвечают ли смежные (наиболее близкие) ему кластеры условиям:

*<math>RI_{(C_{i},C_{j})} \geqslant T_{RI}</math>

*<math>RC_{(C_{i},C_{j})} \geqslant T_{RC}</math>

Если более одного смежного кластера отвечает этим условиям, то алгоритм выбирает для объединения наиболее связный кластер (граф), то есть такой кластер <math>C_{j}</math>, с которым у кластера <math>C_{i}</math> получается наибольшая абсолютная взаимная связность. По завершению прохода по всем кластерам, созданные таким образом пары объединяются. Параметры <math>T_{RI}</math> и <math>T_{RC}</math> могут использоваться для изменения характеристик получаемых кластеров.

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

<math>RI_{(C_{i},C_{j})}*RC_{(C_{i},C_{j})}^\alpha</math>,

где <math>\alpha</math> выбирается пользователем. Если <math>\alpha > 1 </math>, то алгоритм придает большее значение относительному взаимному сходству, а если <math>\alpha < 1 </math>, то большее значение имеет относительная взаимная связность.

''Вычисляемые данные'':

<math>U = (u_1, u_2, ..., u_n)</math> - n-мерный вектор, где <math>u_i \in N_{[C]}</math> - порядковый номер кластера, к которому принадлежит вершина i исходного множества V.

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

Алгоритм имеет три вычислительных ядра, по одному на каждый этап.

На первом этапе вычислительным ядром является процесс нахождения <math>k</math> ближайших соседей для каждой вершины, который заключается в анализе матрицы расстояний.

На втором этапе вычислительным ядром является процесс поиска подходящего разбиения очередного подграфа на два графа с минимизацией разделителя ребер графа.

На третьем этапе вычислительным ядром является расчет величин <math>EC_{(C_{i},C_{j})}</math>, <math>S_{EC_{(C_{i},C_{j})}}</math>, <math>RI_{(C_{i},C_{j})} </math>, <math> RC_{(C_{i},C_{j})}</math> для каждой пары смежных кластеров.

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

Как уже рассказывалось ранее, алгоритм включает в себя три основных этапа, каждый из которых, по сути, является отдельным алгоритмом. Этапы выполняются последовательно относительно друг друга.

Макрооперация на первом этапе - процедура нахождения <math>k</math> ближайших соседей, на втором - процедура разбиения наибольшего подграфа на два графа, на третьем - процедура вычисления показателей сходства, на основе которых принимается решение о слиянии подграфов в кластер.

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

'''Первый этап'''
<source lang="cpp">
int n; //количество вершин
int k; //количество соседей
int A[n][n] //матрица расстояний
int D[k] //массив вершин-соседей
int E[n][n] //матрица ребер графа <math>G_{2} = (K, E_{2})</math>
for i=1 to n-1 do
{
for j=i+1 to n do
{
//заполняем массив вершин-соседей вставляя новые вершины, если они ближе, чем самая далекая из массива.
}
for j=0 to k do
{
//для каждой вершины соседа заполняем соответствующую ячейку из матрицы E[n][n] единицей
}

}
</source>

'''Второй этап'''

1. Все связные подграфы в отсортированном порядке помещаются в список;
2. Берем наибольший элемент списка, вычисляем количество его вершин. Если число вершин > l, то идем в пункт 3. Иначе в пункт 5;
3. Разбиваем подграф на два подграфа таким образом, чтобы разделитель ребер графа был минимален и каждый из получаемых подграфов содержал не менее 25 % вершин исходного графа;
4. Добавляем полученные элементы в список подграфов таким образом, чтобы список оставался отсортированным. Идем в пункт 2;
5. Нашли искомое множество подграфов math>K = \{K_{i}\}</math>;
6. Создаем и заполняем матрицу матрицу расстояний для графа <math>G_{2} = (K, E_{2})</math>. Получаем искомый набор рёбер <math>E_{2}</math>.

'''Третий этап'''

1. Заводим два массива: а) массив кластеров C, полученных на предыдущем этапе, б) массив объединений кластеров F, которые мы будем получать на этом этапе;
2. Берем следующий кластер <math>C_{i}</math> (на первом шаге - первый). Если все кластеры просмотрены, идем в пункт 6;
3. Берем следующий кластер <math>C_{j}, i<>j</math>. Если все кластеры просмотрены, то идем в пункт 2;
4. Проверяем смежность <math>C_{i}</math> и <math>C_{j}</math>. Если не смежны, то возвращаемся в пункт 3. Если смежны, идем в пункт 5;
5. Рассчитываем показатели <math>RI_{(C_{i},C_{j})}</math> и <math> RC_{(C_{i},C_{j})}</math>. Проверяем, удовлетворяют ли найденные значения условиям:
*<math>RI_{(C_{i},C_{j})} \geqslant T_{RI}</math>
*<math>RC_{(C_{i},C_{j})} \geqslant T_{RC}</math>
Если нет, то идем в пункт 3. Иначе если смежность пары кластеров выше, чем у предыдущих найденных, то <math>F_{i}=j</math>. Идем в пункт 3;
6. Если в списке F есть хотя бы одна пара кластеров для слияния, то выполняем слияние, обновляем массив кластеров и массив объединений кластеров. Идем в пункт 2.

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

1) Для построения графа на основе метода k ближайших соседей для n вершин требуется <math>O(n log(n))</math> операций [3]; для наборов данных большой размерности эта величина составляет <math>O(n^2)</math> операций [4];

2) Для выделения множества сравнительно малых связных подграфов требуется <math>nm</math> операций, где <math>m</math> - количество подграфов, полученных на втором этапе алгоритма;

3) Формирование набора кластеров, на основе множества подграфов, полученных на предыдущем этапе, требует <math>m^2log(m)</math> операций.

Итого, для n вершин получаем последовательную сложность <math>O(n log(n)+nm+m^2log(m))</math>.

== Информационный граф ==
[[File:СК.png]]

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

Первый этап работы алгоритма можно распределить между <math>n</math> процессами. На вход каждому процессу подается своя вершина, далее происходит процедура поиска <math>k</math> ближайших соседей. Параллельная сложность составляет <math>O(n)</math>.

Второй и третий этапы можно распараллелить частично.

Второй этап распараллеливается путем подачи на вход свободному процессу очередного подграфа для разделения. Число итераций оценивается в <math>O(n log(n))</math>.

Третий этап делится на расчет показателей схожести и соединение подграфов в кластеры. Процесс расчета показателей можно распараллелить, подавая каждому процессу на вход пару подграфов. Сложность этого процесса оценивается как <math>m log(m)</math>. Соединение подграфов в кластеры выполняется последовательно, сложность процесса составляет <math>m^2 log(m)</math>

Таким образом получаем общую параллельную сложность алгоритма: <math>O(n+ n log(n) + m^2 log (m) + m log(m))</math>

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

1. Симметрическая матрица <math>A</math> расстояний между элементами данных размера <math>n\times n</math> с нулями на главной диагонали (<math>a_{ii}= 0, i = 1, \ldots, N</math>).

2. <math>k</math> - количество ближайших соседей для вершин (рекомендуемое значение <math>k</math> от 5 до 20 в зависимости от количества анализируемых объектов).

3. <math>l</math> - наименьшее число вершин, которое может содержать наибольший подкластер на 2-м этапе . Величина этого параметра варьируется от 1 до 5 % от общего числа объектов.

'''Объём входных данных'''

<math>\frac{n (n - 1)}{2}</math> (в силу симметричности и нулевой главной диагонали достаточно хранить только над/поддиагональные элементы).

'''Выходные данные'''

Вектор из <math>n</math> чисел <math>u_{1}, u_{2}, \ldots, u_{N}</math>, где <math>u_{i}</math> - целое число, соответствующее кластеру <math>i</math>-го объекта.

'''Объём выходных данных'''

<math>n</math>

== Свойства алгоритма ==
Соотношение последовательной и параллельной сложности на первом этапе является ''линейным'' для больших наборов данных и логарифмическим для n вершин. На втором этапе сложно оценить это соотношение - оно сильно зависит от параметров <math>k</math> и <math>l</math>. На третьем этапе соотношение равно <math>O(1)</math>

Алгоритм является недетерминированным. Хотя 1-й этап детерминирован, на 2-ом этапе могут быть найдены различные разбиения на подграфы, что повлияет и на итоговый результат работы алгоритма.

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

см. позднее

== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Последовательная реализация алгоритма доступна по ссылке [5].

CHAMELEON можно реализовать с использованием графовых библиотек METIS [6], hMETIS [7] и RANN [8].

Существует исследование, связанное с реализацией CHAMELEON посредством технологии OpenMP, с которым можно ознакомиться здесь [9].

Параллельных реализаций алгоритма CHAMELEON не найдено.

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

[2] http://studopedia.ru/7_41934_algoritm-dinamicheskoy-ierarhicheskoy-klasterizatsii-CHAMELEON.html

[3] J.H. Friedman, J.L. Bentley, and R.A. Finkel. An algorithm for ﬁnding best matches in logarithmic expected time. ACM Transactions on Mathematical Software, 3:209–226, 1977.

[4] S. Berchtold, C. Bohm, D. Keim, and H.-P. Kriegel. Cost model for nearest neighbor search in high dimensional data space. In Proc. of Symposium on Principles of Database Systems, Tucson, Arizona, 1997.

[5] http://www.codeforge.com/article/192925

[6] http://glaros.dtc.umn.edu/gkhome/metis/metis/overview

[7] http://glaros.dtc.umn.edu/gkhome/metis/hmetis/overview

[8] https://cran.r-project.org/web/packages/RANN/index.html

[9] http://research.ijcaonline.org/volume79/number8/pxc3891600.pdf

Участник:ЕкатеринаКозырева/Алгоритм динамической иерархической кластеризации CHAMELEON

2016-10-31T18:42:54Z

ЕкатеринаКозырева: /* Математическое описание алгоритма */

{{algorithm
| name = Алгоритм динамической иерархической кластеризации CHAMELEON
| serial_complexity = <math>O(nm + n log n + m^2 log m)</math>
| input_data = <math>\frac{n (n - 1)}{2}</math>
| output_data = <math>n</math>
| pf_height = <math>O(n+ n log(n) + m^2 log (m) + m log(m))</math>
| pf_width = <math>O(n)</math>
}}

Автор описания [[Участник:ЕкатеринаКозырева|Е.А.Козырева]]
= Свойства и структура алгоритмов =

== Общее описание алгоритма ==
Алгоритм CHAMELEON был предложен в 1999 году тремя учеными из университета Миннесоты – George Karypis, Eui-Hong (Sam) Han и Vipin Kumar<ref>George Karypis, Eui-Hong (Sam) Han и Vipin Kumar, «Chameleon: Hierarchical Clustering Using Dynamic Modeling», 1999.</ref>.

Предназначен для решения задач кластеризации. Кластеризация (или кластерный анализ) — это задача разбиения множества объектов на группы, называемые кластерами. Внутри каждой группы должны оказаться «похожие» объекты, а объекты разных группы должны быть как можно более отличны.

CHAMELEON - это агломеративный иерархический алгоритм кластеризации, ключевой особенностью которого является то, что он учитывает и взаимную связность, и сходство при определении наиболее похожей пары подкластеров, основываясь на динамической модели. Это означает, что в процессе кластеризации два кластера объединяются, только если их относительная взаимная связность и относительное взаимное сходство являются высокими по отношению к внутренней взаимосвязанности кластеров и близости элементов внутри кластеров. Кроме того, CHAMELEON использует подход для моделирования степени взаимосвязанности и близости между каждой парой кластеров, который учитывает внутренние характеристики самих кластеров. Таким образом, он может автоматически адаптироваться к внутренним характеристикам объединяемых кластеров.

CHAMELEON находит кластеры в наборе данных с помощью трехфазного алгоритма. На первой фазе происходит построение графа, путём добавления рёбер по принципу k ближайших соседей. На второй фазе CHAMELEON группирует полученные элементы в множество относительно небольших подграфов. Во время третьей фазы применяется агломеративный иерархический алгоритм кластеризации, с помощью которого находятся естесственные кластеры путем многократного объединения подграфов, полученных на прошлом этапе.

[[File:Chameleon.png|1000px|thumb|center|Рисунок 1. Общая структура алгоритма CHAMELEON]]

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

''Исходные данные'':

* Множество из n точек <math>V= {v_{ij}}</math> в метрическом пространстве, которое задано симметрической матрицей расстояний <math>A</math> размера <math>n\times n</math>.
* <math>k</math> - количество ближайших соседей для вершин, <math>k \in N, k \leq n</math>.
* <math>l</math> - наименьшее число вершин, которое может содержать наибольший подграф на 2-м этапе, <math>l \in N, l \leq n</math>.

''Обозначения'':

* <math>G = (V, E)</math> - граф, полученный путём соединения каждой точки с её <math>k</math> ближайшими соседями.

* <math>K= \{K_{i}\}</math> - разбиение множества <math>V</math> на набор попарно непересекающихся связных подмножеств, полученное в результате выполнения второй фазы алгоритма.

* <math>G_{2} = (K, E_{2})</math> - взвешенный граф, вершинами которого являются получившиеся подграфы, а ребрами - количество ребер исходного графа, соединяющих соответствующие подграфы.

* <math>C = \{C_{i}\}</math> - итоговое разбиение множества вершин графа <math>G_{2}</math> на набор кластеров.

''Вспомогательные понятия''

*<math>EC_{(C_{i},C_{j})}</math> - абсолютная взаимная связность пары кластеров <math>C_{i}, C{j}</math>. Определяется как сумма весов ребер, соединяющих вершины, принадлежащие <math>C{i}</math> c вершинами из <math>C{j}</math>. Внутренняя связность <math>EC_{(C_{i},C_{i})}</math> вычисляется как сумма ребер, входящих в разделитель, разбивающий <math>C{i}</math> на два равных подграфа.

*<math>RI_{(C_{i},C_{j})} = \frac{|EC_{(C_{i},C_{j})}|}{(|EC_{C_{i}}|+|EC_{C_{j}}|)/2}</math> - относительная взаимная связность пары кластеров <math>C_{i}, C{j}</math>

*<math>S_{EC_{(C_{i},C_{j})}}</math> - абсолютное взаимное сходство пары кластеров <math>C_{i}, C{j}</math>. Подсчитывается как среднее сходство между соединенными вершинами, принадлежащими <math>C{i}</math> и <math>C{j}</math> соответственно. Соединения обусловлены разбиением общего графа, полученного на первом этапе алгоритма.

*<math> RC_{(C_{i},C_{j})}= \frac{S_{EC_{(C_{i},C_{j})}}}{\frac{|C_{i}|}{|C_{i}+C_{j}|}*S_{EC_{(C_{i})}}+\frac{|C_{i}|}{|C_{i}+C_{j}|}*S_{EC_{(C_{j})}}}</math> - относительное взаимное сходство пары кластеров <math>C_{i}, C{j}</math>. Определяется как абсолютное сходство между этой парой кластеров, нормализованное с учетом их внутреннего сходства.

'''Первый этап'''

На первом этапе, согласно графо-ориентированному подходу, происходит построение графа <math>G = (V, E)</math> на матрице сходства объектов по принципу k ближайших соседей. Две вершины такого графа соединяет ребро, если объект, соответствующий любой из этих вершин попадает в число k наиболее близких объектов для объекта, соответствующего другой вершине из данной пары.
[[Файл:Снимок chameleon 2.png|1000px|thumb|center|Рисунок 2. Объекты в пространстве - слева, граф по принципу 1-го ближайшего соседа - по центру, граф по принципу 3-х ближайших соседей - справа ]]

'''Второй этап'''

Алгоритм разделяет полученный граф на множество сравнительно малых подграфов <math>K= \{K_{i}\}</math>. Разделение происходит последовательно. На каждом шаге выбирается подграф, содержащий наибольшее число вершин. Этот граф разделяется на два подграфа так, что разделитель ребер графа минимален и каждый из получаемых подграфов содержит не менее 25 % вершин исходного графа. Процесс разделения останавливается, когда наибольший подграф содержит меньше некоторого заданного числа вершин. Обычно величина этого параметра задается равной значению от 1 до 5 % от числа объектов. Полученное множество связных графов считается множеством начальных кластеров, на котором требуется провести последовательное иерархическое объединение.

'''Третий этап'''

Третий этап заключается в итеративном преобразовании множества подграфов <math>K= \{K_{i}\}</math> в множество кластеров <math>C = \{C_{i}\}</math>. Алгоритм осуществляет агломеративную иерархическую кластеризацию на основании показателей <math>EC_{(C_{i},C_{j})}</math>, <math>S_{EC_{(C_{i},C_{j})}}</math>, <math>RI_{(C_{i},C_{j})} </math>, <math> RC_{(C_{i},C_{j})}</math>. Существует две стратегии анализа показателей сходства. Первая подразумевает наличие некоторых пороговых значений <math>T_{RI}</math> и <math>T_{RC}</math>. В соответствии с этой стратегией, алгоритм для каждого кластера <math>C_{i}</math> проверяет, отвечают ли смежные (наиболее близкие) ему кластеры условиям:

*<math>RI_{(C_{i},C_{j})} \geqslant T_{RI}</math>

*<math>RC_{(C_{i},C_{j})} \geqslant T_{RC}</math>

Если более одного смежного кластера отвечает этим условиям, то алгоритм выбирает для объединения наиболее связный кластер (граф), то есть такой кластер <math>C_{j}</math>, с которым у кластера <math>C_{i}</math> получается наибольшая абсолютная взаимная связность. По завершению прохода по всем кластерам, созданные таким образом пары объединяются. Параметры <math>T_{RI}</math> и <math>T_{RC}</math> могут использоваться для изменения характеристик получаемых кластеров.

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

<math>RI_{(C_{i},C_{j})}*RC_{(C_{i},C_{j})}^\alpha</math>,

где <math>\alpha</math> выбирается пользователем. Если <math>\alpha > 1 </math>, то алгоритм придает большее значение относительному взаимному сходству, а если <math>\alpha < 1 </math>, то большее значение имеет относительная взаимная связность.

''Вычисляемые данные'':

<math>U = (u_1, u_2, ..., u_n)</math> - n-мерный вектор, где <math>u_i \in N_{[C]}</math> - порядковый номер кластера, к которому принадлежит вершина i исходного множества V.

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

Алгоритм имеет три вычислительных ядра, по одному на каждый этап.

На первом этапе вычислительным ядром является процесс нахождения <math>k</math> ближайших соседей для каждой вершины, который заключается в анализе матрицы расстояний.

На втором этапе вычислительным ядром является процесс поиска подходящего разбиения очередного подграфа на два графа с минимизацией разделителя ребер графа.

На третьем этапе вычислительным ядром является расчет величин <math>EC_{(C_{i},C_{j})}</math>, <math>S_{EC_{(C_{i},C_{j})}}</math>, <math>RI_{(C_{i},C_{j})} </math>, <math> RC_{(C_{i},C_{j})}</math> для каждой пары смежных кластеров.

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

Как уже рассказывалось ранее, алгоритм включает в себя три основных этапа, каждый из которых, по сути, является отдельным алгоритмом. Этапы выполняются последовательно относительно друг друга.

Макрооперация на первом этапе - процедура нахождения <math>k</math> ближайших соседей, на втором - процедура разбиения наибольшего подграфа на два графа, на третьем - процедура вычисления показателей сходства, на основе которых принимается решение о слиянии подграфов в кластер.

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

'''Первый этап'''
<source lang="cpp">
int n; //количество вершин
int k; //количество соседей
int A[n][n] //матрица расстояний
int D[k] //массив вершин-соседей
int E[n][n] //матрица ребер графа <math>G_{2} = (K, E_{2})</math>
for i=1 to n-1 do
{
for j=i+1 to n do
{
//заполняем массив вершин-соседей вставляя новые вершины, если они ближе, чем самая далекая из массива.
}
for j=0 to k do
{
//для каждой вершины соседа заполняем соответствующую ячейку из матрицы E[n][n] единицей
}

}
</source>

'''Второй этап'''

1. Все связные подграфы в отсортированном порядке помещаются в список;
2. Берем наибольший элемент списка, вычисляем количество его вершин. Если число вершин > l, то идем в пункт 3. Иначе в пункт 5;
3. Разбиваем подграф на два подграфа таким образом, чтобы разделитель ребер графа был минимален и каждый из получаемых подграфов содержал не менее 25 % вершин исходного графа;
4. Добавляем полученные элементы в список подграфов таким образом, чтобы список оставался отсортированным. Идем в пункт 2;
5. Нашли искомое множество подграфов math>K = \{K_{i}\}</math>;
6. Создаем и заполняем матрицу матрицу расстояний для графа <math>G_{2} = (K, E_{2})</math>. Получаем искомый набор рёбер <math>E_{2}</math>.

'''Третий этап'''

1. Заводим два массива: а) массив кластеров C, полученных на предыдущем этапе, б) массив объединений кластеров F, которые мы будем получать на этом этапе;
2. Берем следующий кластер <math>C_{i}</math> (на первом шаге - первый). Если все кластеры просмотрены, идем в пункт 6;
3. Берем следующий кластер <math>C_{j}, i<>j</math>. Если все кластеры просмотрены, то идем в пункт 2;
4. Проверяем смежность <math>C_{i}</math> и <math>C_{j}</math>. Если не смежны, то возвращаемся в пункт 3. Если смежны, идем в пункт 5;
5. Рассчитываем показатели <math>RI_{(C_{i},C_{j})}</math> и <math> RC_{(C_{i},C_{j})}</math>. Проверяем, удовлетворяют ли найденные значения условиям:
*<math>RI_{(C_{i},C_{j})} \geqslant T_{RI}</math>
*<math>RC_{(C_{i},C_{j})} \geqslant T_{RC}</math>
Если нет, то идем в пункт 3. Иначе если смежность пары кластеров выше, чем у предыдущих найденных, то <math>F_{i}=j</math>. Идем в пункт 3;
6. Если в списке F есть хотя бы одна пара кластеров для слияния, то выполняем слияние, обновляем массив кластеров и массив объединений кластеров. Идем в пункт 2.

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

1) Для построения графа на основе метода k ближайших соседей для n вершин требуется <math>O(n log(n))</math> операций [3]; для наборов данных большой размерности эта величина составляет <math>O(n^2)</math> операций [4];

2) Для выделения множества сравнительно малых связных подграфов требуется <math>nm</math> операций, где <math>m</math> - количество подграфов, полученных на втором этапе алгоритма;

3) Формирование набора кластеров, на основе множества подграфов, полученных на предыдущем этапе, требует <math>m^2log(m)</math> операций.

Итого, для n вершин получаем последовательную сложность <math>O(n log(n)+nm+m^2log(m))</math>.

== Информационный граф ==
[[File:СК.png]]

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

Первый этап работы алгоритма можно распределить между <math>n</math> процессами. На вход каждому процессу подается своя вершина, далее происходит процедура поиска <math>k</math> ближайших соседей. Параллельная сложность составляет <math>O(n)</math>.

Второй и третий этапы можно распараллелить частично.

Второй этап распараллеливается путем подачи на вход свободному процессу очередного подграфа для разделения. Число итераций оценивается в <math>O(n log(n))</math>.

Третий этап делится на расчет показателей схожести и соединение подграфов в кластеры. Процесс расчета показателей можно распараллелить, подавая каждому процессу на вход пару подграфов. Сложность этого процесса оценивается как <math>m log(m)</math>. Соединение подграфов в кластеры выполняется последовательно, сложность процесса составляет <math>m^2 log(m)</math>

Таким образом получаем общую параллельную сложность алгоритма: <math>O(n+ n log(n) + m^2 log (m) + m log(m))</math>

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

1. Симметрическая матрица <math>A</math> расстояний между элементами данных размера <math>n\times n</math> с нулями на главной диагонали (<math>a_{ii}= 0, i = 1, \ldots, N</math>).

2. <math>k</math> - количество ближайших соседей для вершин (рекомендуемое значение <math>k</math> от 5 до 20 в зависимости от количества анализируемых объектов).

3. <math>l</math> - наименьшее число вершин, которое может содержать наибольший подкластер на 2-м этапе . Величина этого параметра варьируется от 1 до 5 % от общего числа объектов.

'''Объём входных данных'''

<math>\frac{n (n - 1)}{2}</math> (в силу симметричности и нулевой главной диагонали достаточно хранить только над/поддиагональные элементы).

'''Выходные данные'''

Вектор из <math>n</math> чисел <math>u_{1}, u_{2}, \ldots, u_{N}</math>, где <math>u_{i}</math> - целое число, соответствующее кластеру <math>i</math>-го объекта.

'''Объём выходных данных'''

<math>n</math>

== Свойства алгоритма ==
Соотношение последовательной и параллельной сложности на первом этапе является ''линейным'' для больших наборов данных и логарифмическим для n вершин. На втором этапе сложно оценить это соотношение - оно сильно зависит от параметров <math>k</math> и <math>l</math>. На третьем этапе соотношение равно <math>O(1)</math>

Алгоритм является недетерминированным. Хотя 1-й этап детерминирован, на 2-ом этапе могут быть найдены различные разбиения на подграфы, что повлияет и на итоговый результат работы алгоритма.

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

см. позднее

== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Последовательная реализация алгоритма доступна по ссылке [5].

CHAMELEON можно реализовать с использованием графовых библиотек METIS [6], hMETIS [7] и RANN [8].

Существует исследование, связанное с реализацией CHAMELEON посредством технологии OpenMP, с которым можно ознакомиться здесь [9].

Параллельных реализаций алгоритма CHAMELEON не найдено.

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

[2] http://studopedia.ru/7_41934_algoritm-dinamicheskoy-ierarhicheskoy-klasterizatsii-CHAMELEON.html

[3] J.H. Friedman, J.L. Bentley, and R.A. Finkel. An algorithm for ﬁnding best matches in logarithmic expected time. ACM Transactions on Mathematical Software, 3:209–226, 1977.

[4] S. Berchtold, C. Bohm, D. Keim, and H.-P. Kriegel. Cost model for nearest neighbor search in high dimensional data space. In Proc. of Symposium on Principles of Database Systems, Tucson, Arizona, 1997.

[5] http://www.codeforge.com/article/192925

[6] http://glaros.dtc.umn.edu/gkhome/metis/metis/overview

[7] http://glaros.dtc.umn.edu/gkhome/metis/hmetis/overview

[8] https://cran.r-project.org/web/packages/RANN/index.html

[9] http://research.ijcaonline.org/volume79/number8/pxc3891600.pdf

Участник:ЕкатеринаКозырева/Алгоритм динамической иерархической кластеризации CHAMELEON

2016-10-31T18:37:02Z

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

{{algorithm
| name = Алгоритм динамической иерархической кластеризации CHAMELEON
| serial_complexity = <math>O(nm + n log n + m^2 log m)</math>
| input_data = <math>\frac{n (n - 1)}{2}</math>
| output_data = <math>n</math>
| pf_height = <math>O(n+ n log(n) + m^2 log (m) + m log(m))</math>
| pf_width = <math>O(n)</math>
}}

Автор описания [[Участник:ЕкатеринаКозырева|Е.А.Козырева]]
= Свойства и структура алгоритмов =

== Общее описание алгоритма ==
Алгоритм CHAMELEON был предложен в 1999 году тремя учеными из университета Миннесоты – George Karypis, Eui-Hong (Sam) Han и Vipin Kumar<ref>George Karypis, Eui-Hong (Sam) Han и Vipin Kumar, «Chameleon: Hierarchical Clustering Using Dynamic Modeling», 1999.</ref>.

Предназначен для решения задач кластеризации. Кластеризация (или кластерный анализ) — это задача разбиения множества объектов на группы, называемые кластерами. Внутри каждой группы должны оказаться «похожие» объекты, а объекты разных группы должны быть как можно более отличны.

CHAMELEON - это агломеративный иерархический алгоритм кластеризации, ключевой особенностью которого является то, что он учитывает и взаимную связность, и сходство при определении наиболее похожей пары подкластеров, основываясь на динамической модели. Это означает, что в процессе кластеризации два кластера объединяются, только если их относительная взаимная связность и относительное взаимное сходство являются высокими по отношению к внутренней взаимосвязанности кластеров и близости элементов внутри кластеров. Кроме того, CHAMELEON использует подход для моделирования степени взаимосвязанности и близости между каждой парой кластеров, который учитывает внутренние характеристики самих кластеров. Таким образом, он может автоматически адаптироваться к внутренним характеристикам объединяемых кластеров.

CHAMELEON находит кластеры в наборе данных с помощью трехфазного алгоритма. На первой фазе происходит построение графа, путём добавления рёбер по принципу k ближайших соседей. На второй фазе CHAMELEON группирует полученные элементы в множество относительно небольших подграфов. Во время третьей фазы применяется агломеративный иерархический алгоритм кластеризации, с помощью которого находятся естесственные кластеры путем многократного объединения подграфов, полученных на прошлом этапе.

[[File:Chameleon.png|1000px|thumb|center|Рисунок 1. Общая структура алгоритма CHAMELEON]]

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

''Исходные данные'':

* Множество из n точек <math>V= {v_{ij}}</math> в метрическом пространстве, которое задано симметрической матрицей расстояний <math>A</math> размера <math>n\times n</math>.
* <math>k</math> - количество ближайших соседей для вершин, <math>k \in N, k \leq n</math>.
* <math>l</math> - наименьшее число вершин, которое может содержать наибольший подграф на 2-м этапе, <math>l \in N, l \leq n</math>.

''Обозначения'':

* <math>G = (V, E)</math> - граф, полученный путём соединения каждой точки с её <math>k</math> ближайшими соседями.

* <math>K= \{K_{i}\}</math> - разбиение множества <math>V</math> на набор попарно непересекающихся связных подмножеств, полученное в результате выполнения второй фазы алгоритма.

* <math>G_{2} = (K, E_{2})</math> - взвешенный граф, вершинами которого являются получившиеся подграфы, а ребрами - количество ребер исходного графа, соединяющих соответствующие подграфы.

* <math>C = \{C_{i}\}</math> - итоговое разбиение множества вершин графа <math>G_{2}</math> на набор кластеров.

''Вспомогательные понятия''

*<math>EC_{(C_{i},C_{j})}</math> - абсолютная взаимная связность пары кластеров <math>C_{i}, C{j}</math>. Определяется как сумма весов ребер, соединяющих вершины, принадлежащие <math>C{i}</math> c вершинами из <math>C{j}</math>. Внутренняя связность <math>EC_{(C_{i},C_{i})}</math> вычисляется как сумма ребер, входящих в разделитель, разбивающий <math>C{i}</math> на два равных подграфа.

*<math>RI_{(C_{i},C_{j})} = \frac{|EC_{(C_{i},C_{j})}|}{(|EC_{C_{i}}|+|EC_{C_{j}}|)/2}</math> - относительная взаимная связность пары кластеров <math>C_{i}, C{j}</math>

*<math>S_{EC_{(C_{i},C_{j})}}</math> - абсолютное взаимное сходство пары кластеров <math>C_{i}, C{j}</math>. Подсчитывается как среднее сходство между соединенными вершинами, принадлежащими <math>C{i}</math> и <math>C{j}</math> соответственно. Соединения обусловлены разбиением общего графа, полученного на первом этапе алгоритма.

*<math> RC_{(C_{i},C_{j})}= \frac{S_{EC_{(C_{i},C_{j})}}}{\frac{|C_{i}|}{|C_{i}+C_{j}|}*S_{EC_{(C_{i})}}+\frac{|C_{i}|}{|C_{i}+C_{j}|}*S_{EC_{(C_{j})}}}</math> - относительное взаимное сходство пары кластеров <math>C_{i}, C{j}</math>. Определяется как абсолютное сходство между этой парой кластеров, нормализованное с учетом их внутреннего сходства.

'''Первый этап'''

На первом этапе, согласно графо-ориентированному подходу, происходит построение графа <math>G = (V, E)</math> на матрице сходства объектов по принципу k ближайших соседей. Две вершины такого графа соединяет ребро, если объект, соответствующий любой из этих вершин попадает в число k наиболее близких объектов для объекта, соответствующего другой вершине из данной пары.
[[Файл:Снимок chameleon.PNG]]

'''Второй этап'''

Алгоритм разделяет полученный граф на множество сравнительно малых подграфов <math>K= \{K_{i}\}</math>. Разделение происходит последовательно. На каждом шаге выбирается подграф, содержащий наибольшее число вершин. Этот граф разделяется на два подграфа так, что разделитель ребер графа минимален и каждый из получаемых подграфов содержит не менее 25 % вершин исходного графа. Процесс разделения останавливается, когда наибольший подграф содержит меньше некоторого заданного числа вершин. Обычно величина этого параметра задается равной значению от 1 до 5 % от числа объектов. Полученное множество связных графов считается множеством начальных кластеров, на котором требуется провести последовательное иерархическое объединение.

'''Третий этап'''

Третий этап заключается в итеративном преобразовании множества подграфов <math>K= \{K_{i}\}</math> в множество кластеров <math>C = \{C_{i}\}</math>. Алгоритм осуществляет агломеративную иерархическую кластеризацию на основании показателей <math>EC_{(C_{i},C_{j})}</math>, <math>S_{EC_{(C_{i},C_{j})}}</math>, <math>RI_{(C_{i},C_{j})} </math>, <math> RC_{(C_{i},C_{j})}</math>. Существует две стратегии анализа показателей сходства. Первая подразумевает наличие некоторых пороговых значений <math>T_{RI}</math> и <math>T_{RC}</math>. В соответствии с этой стратегией, алгоритм для каждого кластера <math>C_{i}</math> проверяет, отвечают ли смежные (наиболее близкие) ему кластеры условиям:

*<math>RI_{(C_{i},C_{j})} \geqslant T_{RI}</math>

*<math>RC_{(C_{i},C_{j})} \geqslant T_{RC}</math>

Если более одного смежного кластера отвечает этим условиям, то алгоритм выбирает для объединения наиболее связный кластер (граф), то есть такой кластер <math>C_{j}</math>, с которым у кластера <math>C_{i}</math> получается наибольшая абсолютная взаимная связность. По завершению прохода по всем кластерам, созданные таким образом пары объединяются. Параметры <math>T_{RI}</math> и <math>T_{RC}</math> могут использоваться для изменения характеристик получаемых кластеров.

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

<math>RI_{(C_{i},C_{j})}*RC_{(C_{i},C_{j})}^\alpha</math>,

где <math>\alpha</math> выбирается пользователем. Если <math>\alpha > 1 </math>, то алгоритм придает большее значение относительному взаимному сходству, а если <math>\alpha < 1 </math>, то большее значение имеет относительная взаимная связность.

''Вычисляемые данные'':

<math>U = (u_1, u_2, ..., u_n)</math> - n-мерный вектор, где <math>u_i \in N_{[C]}</math> - порядковый номер кластера, к которому принадлежит вершина i исходного множества V.

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

Алгоритм имеет три вычислительных ядра, по одному на каждый этап.

На первом этапе вычислительным ядром является процесс нахождения <math>k</math> ближайших соседей для каждой вершины, который заключается в анализе матрицы расстояний.

На втором этапе вычислительным ядром является процесс поиска подходящего разбиения очередного подграфа на два графа с минимизацией разделителя ребер графа.

На третьем этапе вычислительным ядром является расчет величин <math>EC_{(C_{i},C_{j})}</math>, <math>S_{EC_{(C_{i},C_{j})}}</math>, <math>RI_{(C_{i},C_{j})} </math>, <math> RC_{(C_{i},C_{j})}</math> для каждой пары смежных кластеров.

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

Как уже рассказывалось ранее, алгоритм включает в себя три основных этапа, каждый из которых, по сути, является отдельным алгоритмом. Этапы выполняются последовательно относительно друг друга.

Макрооперация на первом этапе - процедура нахождения <math>k</math> ближайших соседей, на втором - процедура разбиения наибольшего подграфа на два графа, на третьем - процедура вычисления показателей сходства, на основе которых принимается решение о слиянии подграфов в кластер.

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

'''Первый этап'''
<source lang="cpp">
int n; //количество вершин
int k; //количество соседей
int A[n][n] //матрица расстояний
int D[k] //массив вершин-соседей
int E[n][n] //матрица ребер графа <math>G_{2} = (K, E_{2})</math>
for i=1 to n-1 do
{
for j=i+1 to n do
{
//заполняем массив вершин-соседей вставляя новые вершины, если они ближе, чем самая далекая из массива.
}
for j=0 to k do
{
//для каждой вершины соседа заполняем соответствующую ячейку из матрицы E[n][n] единицей
}

}
</source>

'''Второй этап'''

1. Все связные подграфы в отсортированном порядке помещаются в список;
2. Берем наибольший элемент списка, вычисляем количество его вершин. Если число вершин > l, то идем в пункт 3. Иначе в пункт 5;
3. Разбиваем подграф на два подграфа таким образом, чтобы разделитель ребер графа был минимален и каждый из получаемых подграфов содержал не менее 25 % вершин исходного графа;
4. Добавляем полученные элементы в список подграфов таким образом, чтобы список оставался отсортированным. Идем в пункт 2;
5. Нашли искомое множество подграфов math>K = \{K_{i}\}</math>;
6. Создаем и заполняем матрицу матрицу расстояний для графа <math>G_{2} = (K, E_{2})</math>. Получаем искомый набор рёбер <math>E_{2}</math>.

'''Третий этап'''

1. Заводим два массива: а) массив кластеров C, полученных на предыдущем этапе, б) массив объединений кластеров F, которые мы будем получать на этом этапе;
2. Берем следующий кластер <math>C_{i}</math> (на первом шаге - первый). Если все кластеры просмотрены, идем в пункт 6;
3. Берем следующий кластер <math>C_{j}, i<>j</math>. Если все кластеры просмотрены, то идем в пункт 2;
4. Проверяем смежность <math>C_{i}</math> и <math>C_{j}</math>. Если не смежны, то возвращаемся в пункт 3. Если смежны, идем в пункт 5;
5. Рассчитываем показатели <math>RI_{(C_{i},C_{j})}</math> и <math> RC_{(C_{i},C_{j})}</math>. Проверяем, удовлетворяют ли найденные значения условиям:
*<math>RI_{(C_{i},C_{j})} \geqslant T_{RI}</math>
*<math>RC_{(C_{i},C_{j})} \geqslant T_{RC}</math>
Если нет, то идем в пункт 3. Иначе если смежность пары кластеров выше, чем у предыдущих найденных, то <math>F_{i}=j</math>. Идем в пункт 3;
6. Если в списке F есть хотя бы одна пара кластеров для слияния, то выполняем слияние, обновляем массив кластеров и массив объединений кластеров. Идем в пункт 2.

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

1) Для построения графа на основе метода k ближайших соседей для n вершин требуется <math>O(n log(n))</math> операций [3]; для наборов данных большой размерности эта величина составляет <math>O(n^2)</math> операций [4];

2) Для выделения множества сравнительно малых связных подграфов требуется <math>nm</math> операций, где <math>m</math> - количество подграфов, полученных на втором этапе алгоритма;

3) Формирование набора кластеров, на основе множества подграфов, полученных на предыдущем этапе, требует <math>m^2log(m)</math> операций.

Итого, для n вершин получаем последовательную сложность <math>O(n log(n)+nm+m^2log(m))</math>.

== Информационный граф ==
[[File:СК.png]]

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

Первый этап работы алгоритма можно распределить между <math>n</math> процессами. На вход каждому процессу подается своя вершина, далее происходит процедура поиска <math>k</math> ближайших соседей. Параллельная сложность составляет <math>O(n)</math>.

Второй и третий этапы можно распараллелить частично.

Второй этап распараллеливается путем подачи на вход свободному процессу очередного подграфа для разделения. Число итераций оценивается в <math>O(n log(n))</math>.

Третий этап делится на расчет показателей схожести и соединение подграфов в кластеры. Процесс расчета показателей можно распараллелить, подавая каждому процессу на вход пару подграфов. Сложность этого процесса оценивается как <math>m log(m)</math>. Соединение подграфов в кластеры выполняется последовательно, сложность процесса составляет <math>m^2 log(m)</math>

Таким образом получаем общую параллельную сложность алгоритма: <math>O(n+ n log(n) + m^2 log (m) + m log(m))</math>

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

1. Симметрическая матрица <math>A</math> расстояний между элементами данных размера <math>n\times n</math> с нулями на главной диагонали (<math>a_{ii}= 0, i = 1, \ldots, N</math>).

2. <math>k</math> - количество ближайших соседей для вершин (рекомендуемое значение <math>k</math> от 5 до 20 в зависимости от количества анализируемых объектов).

3. <math>l</math> - наименьшее число вершин, которое может содержать наибольший подкластер на 2-м этапе . Величина этого параметра варьируется от 1 до 5 % от общего числа объектов.

'''Объём входных данных'''

<math>\frac{n (n - 1)}{2}</math> (в силу симметричности и нулевой главной диагонали достаточно хранить только над/поддиагональные элементы).

'''Выходные данные'''

Вектор из <math>n</math> чисел <math>u_{1}, u_{2}, \ldots, u_{N}</math>, где <math>u_{i}</math> - целое число, соответствующее кластеру <math>i</math>-го объекта.

'''Объём выходных данных'''

<math>n</math>

== Свойства алгоритма ==
Соотношение последовательной и параллельной сложности на первом этапе является ''линейным'' для больших наборов данных и логарифмическим для n вершин. На втором этапе сложно оценить это соотношение - оно сильно зависит от параметров <math>k</math> и <math>l</math>. На третьем этапе соотношение равно <math>O(1)</math>

Алгоритм является недетерминированным. Хотя 1-й этап детерминирован, на 2-ом этапе могут быть найдены различные разбиения на подграфы, что повлияет и на итоговый результат работы алгоритма.

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

см. позднее

== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Последовательная реализация алгоритма доступна по ссылке [5].

CHAMELEON можно реализовать с использованием графовых библиотек METIS [6], hMETIS [7] и RANN [8].

Существует исследование, связанное с реализацией CHAMELEON посредством технологии OpenMP, с которым можно ознакомиться здесь [9].

Параллельных реализаций алгоритма CHAMELEON не найдено.

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

[2] http://studopedia.ru/7_41934_algoritm-dinamicheskoy-ierarhicheskoy-klasterizatsii-CHAMELEON.html

[3] J.H. Friedman, J.L. Bentley, and R.A. Finkel. An algorithm for ﬁnding best matches in logarithmic expected time. ACM Transactions on Mathematical Software, 3:209–226, 1977.

[4] S. Berchtold, C. Bohm, D. Keim, and H.-P. Kriegel. Cost model for nearest neighbor search in high dimensional data space. In Proc. of Symposium on Principles of Database Systems, Tucson, Arizona, 1997.

[5] http://www.codeforge.com/article/192925

[6] http://glaros.dtc.umn.edu/gkhome/metis/metis/overview

[7] http://glaros.dtc.umn.edu/gkhome/metis/hmetis/overview

[8] https://cran.r-project.org/web/packages/RANN/index.html

[9] http://research.ijcaonline.org/volume79/number8/pxc3891600.pdf

Участник:ЕкатеринаКозырева/Алгоритм динамической иерархической кластеризации CHAMELEON

2016-10-31T18:34:38Z

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

{{algorithm
| name = Алгоритм динамической иерархической кластеризации CHAMELEON
| serial_complexity = <math>O(nm + n log n + m^2 log m)</math>
| input_data = <math>\frac{n (n - 1)}{2}</math>
| output_data = <math>n</math>
| pf_height = <math>O(n+ n log(n) + m^2 log (m) + m log(m))</math>
| pf_width = <math>O(n)</math>
}}

Автор описания [[Участник:ЕкатеринаКозырева|Е.А.Козырева]]
= Свойства и структура алгоритмов =

== Общее описание алгоритма ==
Алгоритм CHAMELEON был предложен в 1999 году тремя учеными из университета Миннесоты – George Karypis, Eui-Hong (Sam) Han и Vipin Kumar<ref>George Karypis, Eui-Hong (Sam) Han и Vipin Kumar, «Chameleon: Hierarchical Clustering Using Dynamic Modeling», 1999.</ref>.

Предназначен для решения задач кластеризации. Кластеризация (или кластерный анализ) — это задача разбиения множества объектов на группы, называемые кластерами. Внутри каждой группы должны оказаться «похожие» объекты, а объекты разных группы должны быть как можно более отличны.

CHAMELEON - это агломеративный иерархический алгоритм кластеризации, ключевой особенностью которого является то, что он учитывает и взаимную связность, и сходство при определении наиболее похожей пары подкластеров, основываясь на динамической модели. Это означает, что в процессе кластеризации два кластера объединяются, только если их относительная взаимная связность и относительное взаимное сходство являются высокими по отношению к внутренней взаимосвязанности кластеров и близости элементов внутри кластеров. Кроме того, CHAMELEON использует подход для моделирования степени взаимосвязанности и близости между каждой парой кластеров, который учитывает внутренние характеристики самих кластеров. Таким образом, он может автоматически адаптироваться к внутренним характеристикам объединяемых кластеров.

CHAMELEON находит кластеры в наборе данных с помощью трехфазного алгоритма. На первой фазе происходит построение графа, путём добавления рёбер по принципу k ближайших соседей. На второй фазе CHAMELEON группирует полученные элементы в множество относительно небольших подграфов. Во время третьей фазы применяется агломеративный иерархический алгоритм кластеризации, с помощью которого находятся естесственные кластеры путем многократного объединения подграфов, полученных на прошлом этапе.

[[File:Chameleon.png|1000px|thumb|center|Рисунок 1. Общая структура алгоритма CHAMELEON]]

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

''Исходные данные'':

* Множество из n точек <math>V= {v_{ij}}</math> в метрическом пространстве, которое задано симметрической матрицей расстояний <math>A</math> размера <math>n\times n</math>.
* <math>k</math> - количество ближайших соседей для вершин, <math>k \in N, k \leq n</math>.
* <math>l</math> - наименьшее число вершин, которое может содержать наибольший подграф на 2-м этапе, <math>l \in N, l \leq n</math>.

''Обозначения'':

* <math>G = (V, E)</math> - граф, полученный путём соединения каждой точки с её <math>k</math> ближайшими соседями.

* <math>K= \{K_{i}\}</math> - разбиение множества <math>V</math> на набор попарно непересекающихся связных подмножеств, полученное в результате выполнения второй фазы алгоритма.

* <math>G_{2} = (K, E_{2})</math> - взвешенный граф, вершинами которого являются получившиеся подграфы, а ребрами - количество ребер исходного графа, соединяющих соответствующие подграфы.

* <math>C = \{C_{i}\}</math> - итоговое разбиение множества вершин графа <math>G_{2}</math> на набор кластеров.

''Вспомогательные понятия''

*<math>EC_{(C_{i},C_{j})}</math> - абсолютная взаимная связность пары кластеров <math>C_{i}, C{j}</math>. Определяется как сумма весов ребер, соединяющих вершины, принадлежащие <math>C{i}</math> c вершинами из <math>C{j}</math>. Внутренняя связность <math>EC_{(C_{i},C_{i})}</math> вычисляется как сумма ребер, входящих в разделитель, разбивающий <math>C{i}</math> на два равных подграфа.

*<math>RI_{(C_{i},C_{j})} = \frac{|EC_{(C_{i},C_{j})}|}{(|EC_{C_{i}}|+|EC_{C_{j}}|)/2}</math> - относительная взаимная связность пары кластеров <math>C_{i}, C{j}</math>

*<math>S_{EC_{(C_{i},C_{j})}}</math> - абсолютное взаимное сходство пары кластеров <math>C_{i}, C{j}</math>. Подсчитывается как среднее сходство между соединенными вершинами, принадлежащими <math>C{i}</math> и <math>C{j}</math> соответственно. Соединения обусловлены разбиением общего графа, полученного на первом этапе алгоритма.

*<math> RC_{(C_{i},C_{j})}= \frac{S_{EC_{(C_{i},C_{j})}}}{\frac{|C_{i}|}{|C_{i}+C_{j}|}*S_{EC_{(C_{i})}}+\frac{|C_{i}|}{|C_{i}+C_{j}|}*S_{EC_{(C_{j})}}}</math> - относительное взаимное сходство пары кластеров <math>C_{i}, C{j}</math>. Определяется как абсолютное сходство между этой парой кластеров, нормализованное с учетом их внутреннего сходства.

'''Первый этап'''

На первом этапе, согласно графо-ориентированному подходу, происходит построение графа <math>G = (V, E)</math> на матрице сходства объектов по принципу k ближайших соседей. Две вершины такого графа соединяет ребро, если объект, соответствующий любой из этих вершин попадает в число k наиболее близких объектов для объекта, соответствующего другой вершине из данной пары.
[[Файл:Снимок chameleon.PNG]]

'''Второй этап'''

Алгоритм разделяет полученный граф на множество сравнительно малых подграфов <math>K= \{K_{i}\}</math>. Разделение происходит последовательно. На каждом шаге выбирается подграф, содержащий наибольшее число вершин. Этот граф разделяется на два подграфа так, что разделитель ребер графа минимален и каждый из получаемых подграфов содержит не менее 25 % вершин исходного графа. Процесс разделения останавливается, когда наибольший подграф содержит меньше некоторого заданного числа вершин. Обычно величина этого параметра задается равной значению от 1 до 5 % от числа объектов. Полученное множество связных графов считается множеством начальных кластеров, на котором требуется провести последовательное иерархическое объединение.

'''Третий этап'''

Третий этап заключается в итеративном преобразовании множества подграфов <math>K= \{K_{i}\}</math> в множество кластеров <math>C = \{C_{i}\}</math>. Алгоритм осуществляет агломеративную иерархическую кластеризацию на основании показателей <math>EC_{(C_{i},C_{j})}</math>, <math>S_{EC_{(C_{i},C_{j})}}</math>, <math>RI_{(C_{i},C_{j})} </math>, <math> RC_{(C_{i},C_{j})}</math>. Существует две стратегии анализа показателей сходства. Первая подразумевает наличие некоторых пороговых значений <math>T_{RI}</math> и <math>T_{RC}</math>. В соответствии с этой стратегией, алгоритм для каждого кластера <math>C_{i}</math> проверяет, отвечают ли смежные (наиболее близкие) ему кластеры условиям:

*<math>RI_{(C_{i},C_{j})} \geqslant T_{RI}</math>

*<math>RC_{(C_{i},C_{j})} \geqslant T_{RC}</math>

Если более одного смежного кластера отвечает этим условиям, то алгоритм выбирает для объединения наиболее связный кластер (граф), то есть такой кластер <math>C_{j}</math>, с которым у кластера <math>C_{i}</math> получается наибольшая абсолютная взаимная связность. По завершению прохода по всем кластерам, созданные таким образом пары объединяются. Параметры <math>T_{RI}</math> и <math>T_{RC}</math> могут использоваться для изменения характеристик получаемых кластеров.

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

<math>RI_{(C_{i},C_{j})}*RC_{(C_{i},C_{j})}^\alpha</math>,

где <math>\alpha</math> выбирается пользователем. Если <math>\alpha > 1 </math>, то алгоритм придает большее значение относительному взаимному сходству, а если <math>\alpha < 1 </math>, то большее значение имеет относительная взаимная связность.

''Вычисляемые данные'':

<math>U = (u_1, u_2, ..., u_n)</math> - n-мерный вектор, где <math>u_i \in N_{[C]}</math> - порядковый номер кластера, к которому принадлежит вершина i исходного множества V.

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

Алгоритм имеет три вычислительных ядра, по одному на каждый этап.

На первом этапе вычислительным ядром является процесс нахождения <math>k</math> ближайших соседей для каждой вершины, который заключается в анализе матрицы расстояний.

На втором этапе вычислительным ядром является процесс поиска подходящего разбиения очередного подграфа на два графа с минимизацией разделителя ребер графа.

На третьем этапе вычислительным ядром является расчет величин <math>EC_{(C_{i},C_{j})}</math>, <math>S_{EC_{(C_{i},C_{j})}}</math>, <math>RI_{(C_{i},C_{j})} </math>, <math> RC_{(C_{i},C_{j})}</math> для каждой пары смежных кластеров.

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

Как уже рассказывалось ранее, алгоритм включает в себя три основных этапа, каждый из которых, по сути, является отдельным алгоритмом. Этапы выполняются последовательно относительно друг друга.

Макрооперация на первом этапе - процедура нахождения <math>k</math> ближайших соседей, на втором - процедура разбиения наибольшего подграфа на два графа, на третьем - процедура вычисления показателей сходства, на основе которых принимается решение о слиянии подграфов в кластер.

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

'''Первый этап'''
<nowiki>
int n; //количество вершин
int k; //количество соседей
int A[n][n] //матрица расстояний
int D[k] //массив вершин-соседей
int E[n][n] //матрица ребер графа <math>G_{2} = (K, E_{2})</math>
for i=1 to n-1 do
{
for j=i+1 to n do
{
//заполняем массив вершин-соседей вставляя новые вершины, если они ближе, чем самая далекая из массива.
}
for j=0 to k do
{
//для каждой вершины соседа заполняем соответствующую ячейку из матрицы E[n][n] единицей
}

}
</nowiki>

'''Второй этап'''

1. Все связные подграфы в отсортированном порядке помещаются в список;
2. Берем наибольший элемент списка, вычисляем количество его вершин. Если число вершин > l, то идем в пункт 3. Иначе в пункт 5;
3. Разбиваем подграф на два подграфа таким образом, чтобы разделитель ребер графа был минимален и каждый из получаемых подграфов содержал не менее 25 % вершин исходного графа;
4. Добавляем полученные элементы в список подграфов таким образом, чтобы список оставался отсортированным. Идем в пункт 2;
5. Нашли искомое множество подграфов math>K = \{K_{i}\}</math>;
6. Создаем и заполняем матрицу матрицу расстояний для графа <math>G_{2} = (K, E_{2})</math>. Получаем искомый набор рёбер <math>E_{2}</math>.

'''Третий этап'''

1. Заводим два массива: а) массив кластеров C, полученных на предыдущем этапе, б) массив объединений кластеров F, которые мы будем получать на этом этапе;
2. Берем следующий кластер <math>C_{i}</math> (на первом шаге - первый). Если все кластеры просмотрены, идем в пункт 6;
3. Берем следующий кластер <math>C_{j}, i<>j</math>. Если все кластеры просмотрены, то идем в пункт 2;
4. Проверяем смежность <math>C_{i}</math> и <math>C_{j}</math>. Если не смежны, то возвращаемся в пункт 3. Если смежны, идем в пункт 5;
5. Рассчитываем показатели <math>RI_{(C_{i},C_{j})}</math> и <math> RC_{(C_{i},C_{j})}</math>. Проверяем, удовлетворяют ли найденные значения условиям:
*<math>RI_{(C_{i},C_{j})} \geqslant T_{RI}</math>
*<math>RC_{(C_{i},C_{j})} \geqslant T_{RC}</math>
Если нет, то идем в пункт 3. Иначе если смежность пары кластеров выше, чем у предыдущих найденных, то <math>F_{i}=j</math>. Идем в пункт 3;
6. Если в списке F есть хотя бы одна пара кластеров для слияния, то выполняем слияние, обновляем массив кластеров и массив объединений кластеров. Идем в пункт 2.

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

1) Для построения графа на основе метода k ближайших соседей для n вершин требуется <math>O(n log(n))</math> операций [3]; для наборов данных большой размерности эта величина составляет <math>O(n^2)</math> операций [4];

2) Для выделения множества сравнительно малых связных подграфов требуется <math>nm</math> операций, где <math>m</math> - количество подграфов, полученных на втором этапе алгоритма;

3) Формирование набора кластеров, на основе множества подграфов, полученных на предыдущем этапе, требует <math>m^2log(m)</math> операций.

Итого, для n вершин получаем последовательную сложность <math>O(n log(n)+nm+m^2log(m))</math>.

== Информационный граф ==
[[File:СК.png]]

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

Первый этап работы алгоритма можно распределить между <math>n</math> процессами. На вход каждому процессу подается своя вершина, далее происходит процедура поиска <math>k</math> ближайших соседей. Параллельная сложность составляет <math>O(n)</math>.

Второй и третий этапы можно распараллелить частично.

Второй этап распараллеливается путем подачи на вход свободному процессу очередного подграфа для разделения. Число итераций оценивается в <math>O(n log(n))</math>.

Третий этап делится на расчет показателей схожести и соединение подграфов в кластеры. Процесс расчета показателей можно распараллелить, подавая каждому процессу на вход пару подграфов. Сложность этого процесса оценивается как <math>m log(m)</math>. Соединение подграфов в кластеры выполняется последовательно, сложность процесса составляет <math>m^2 log(m)</math>

Таким образом получаем общую параллельную сложность алгоритма: <math>O(n+ n log(n) + m^2 log (m) + m log(m))</math>

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

1. Симметрическая матрица <math>A</math> расстояний между элементами данных размера <math>n\times n</math> с нулями на главной диагонали (<math>a_{ii}= 0, i = 1, \ldots, N</math>).

2. <math>k</math> - количество ближайших соседей для вершин (рекомендуемое значение <math>k</math> от 5 до 20 в зависимости от количества анализируемых объектов).

3. <math>l</math> - наименьшее число вершин, которое может содержать наибольший подкластер на 2-м этапе . Величина этого параметра варьируется от 1 до 5 % от общего числа объектов.

'''Объём входных данных'''

<math>\frac{n (n - 1)}{2}</math> (в силу симметричности и нулевой главной диагонали достаточно хранить только над/поддиагональные элементы).

'''Выходные данные'''

Вектор из <math>n</math> чисел <math>u_{1}, u_{2}, \ldots, u_{N}</math>, где <math>u_{i}</math> - целое число, соответствующее кластеру <math>i</math>-го объекта.

'''Объём выходных данных'''

<math>n</math>

== Свойства алгоритма ==
Соотношение последовательной и параллельной сложности на первом этапе является ''линейным'' для больших наборов данных и логарифмическим для n вершин. На втором этапе сложно оценить это соотношение - оно сильно зависит от параметров <math>k</math> и <math>l</math>. На третьем этапе соотношение равно <math>O(1)</math>

Алгоритм является недетерминированным. Хотя 1-й этап детерминирован, на 2-ом этапе могут быть найдены различные разбиения на подграфы, что повлияет и на итоговый результат работы алгоритма.

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

см. позднее

== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Последовательная реализация алгоритма доступна по ссылке [5].

CHAMELEON можно реализовать с использованием графовых библиотек METIS [6], hMETIS [7] и RANN [8].

Существует исследование, связанное с реализацией CHAMELEON посредством технологии OpenMP, с которым можно ознакомиться здесь [9].

Параллельных реализаций алгоритма CHAMELEON не найдено.

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

[2] http://studopedia.ru/7_41934_algoritm-dinamicheskoy-ierarhicheskoy-klasterizatsii-CHAMELEON.html

[3] J.H. Friedman, J.L. Bentley, and R.A. Finkel. An algorithm for ﬁnding best matches in logarithmic expected time. ACM Transactions on Mathematical Software, 3:209–226, 1977.

[4] S. Berchtold, C. Bohm, D. Keim, and H.-P. Kriegel. Cost model for nearest neighbor search in high dimensional data space. In Proc. of Symposium on Principles of Database Systems, Tucson, Arizona, 1997.

[5] http://www.codeforge.com/article/192925

[6] http://glaros.dtc.umn.edu/gkhome/metis/metis/overview

[7] http://glaros.dtc.umn.edu/gkhome/metis/hmetis/overview

[8] https://cran.r-project.org/web/packages/RANN/index.html

[9] http://research.ijcaonline.org/volume79/number8/pxc3891600.pdf

Участник:ЕкатеринаКозырева/Алгоритм динамической иерархической кластеризации CHAMELEON

2016-10-31T18:32:21Z

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

{{algorithm
| name = Алгоритм динамической иерархической кластеризации CHAMELEON
| serial_complexity = <math>O(nm + n log n + m^2 log m)</math>
| input_data = <math>\frac{n (n - 1)}{2}</math>
| output_data = <math>n</math>
| pf_height = <math>O(n+ n log(n) + m^2 log (m) + m log(m))</math>
| pf_width = <math>O(n)</math>
}}

Автор описания [[Участник:ЕкатеринаКозырева|Е.А.Козырева]]
= Свойства и структура алгоритмов =

== Общее описание алгоритма ==
Алгоритм CHAMELEON был предложен в 1999 году тремя учеными из университета Миннесоты – George Karypis, Eui-Hong (Sam) Han и Vipin Kumar<ref>George Karypis, Eui-Hong (Sam) Han и Vipin Kumar, «Chameleon: Hierarchical Clustering Using Dynamic Modeling», 1999.</ref>.

Предназначен для решения задач кластеризации. Кластеризация (или кластерный анализ) — это задача разбиения множества объектов на группы, называемые кластерами. Внутри каждой группы должны оказаться «похожие» объекты, а объекты разных группы должны быть как можно более отличны.

CHAMELEON - это агломеративный иерархический алгоритм кластеризации, ключевой особенностью которого является то, что он учитывает и взаимную связность, и сходство при определении наиболее похожей пары подкластеров, основываясь на динамической модели. Это означает, что в процессе кластеризации два кластера объединяются, только если их относительная взаимная связность и относительное взаимное сходство являются высокими по отношению к внутренней взаимосвязанности кластеров и близости элементов внутри кластеров. Кроме того, CHAMELEON использует подход для моделирования степени взаимосвязанности и близости между каждой парой кластеров, который учитывает внутренние характеристики самих кластеров. Таким образом, он может автоматически адаптироваться к внутренним характеристикам объединяемых кластеров.

CHAMELEON находит кластеры в наборе данных с помощью трехфазного алгоритма. На первой фазе происходит построение графа, путём добавления рёбер по принципу k ближайших соседей. На второй фазе CHAMELEON группирует полученные элементы в множество относительно небольших подграфов. Во время третьей фазы применяется агломеративный иерархический алгоритм кластеризации, с помощью которого находятся естесственные кластеры путем многократного объединения подграфов, полученных на прошлом этапе.

[[File:Chameleon.png|1000px|thumb|center|Рисунок 1. Общая структура алгоритма CHAMELEON]]

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

''Исходные данные'':

* Множество из n точек <math>V= {v_{ij}}</math> в метрическом пространстве, которое задано симметрической матрицей расстояний <math>A</math> размера <math>n\times n</math>.
* <math>k</math> - количество ближайших соседей для вершин, <math>k \in N, k \leq n</math>.
* <math>l</math> - наименьшее число вершин, которое может содержать наибольший подграф на 2-м этапе, <math>l \in N, l \leq n</math>.

''Обозначения'':

* <math>G = (V, E)</math> - граф, полученный путём соединения каждой точки с её <math>k</math> ближайшими соседями.

* <math>K= \{K_{i}\}</math> - разбиение множества <math>V</math> на набор попарно непересекающихся связных подмножеств, полученное в результате выполнения второй фазы алгоритма.

* <math>G_{2} = (K, E_{2})</math> - взвешенный граф, вершинами которого являются получившиеся подграфы, а ребрами - количество ребер исходного графа, соединяющих соответствующие подграфы.

* <math>C = \{C_{i}\}</math> - итоговое разбиение множества вершин графа <math>G_{2}</math> на набор кластеров.

''Вспомогательные понятия''

*<math>EC_{(C_{i},C_{j})}</math> - абсолютная взаимная связность пары кластеров <math>C_{i}, C{j}</math>. Определяется как сумма весов ребер, соединяющих вершины, принадлежащие <math>C{i}</math> c вершинами из <math>C{j}</math>. Внутренняя связность <math>EC_{(C_{i},C_{i})}</math> вычисляется как сумма ребер, входящих в разделитель, разбивающий <math>C{i}</math> на два равных подграфа.

*<math>RI_{(C_{i},C_{j})} = \frac{|EC_{(C_{i},C_{j})}|}{(|EC_{C_{i}}|+|EC_{C_{j}}|)/2}</math> - относительная взаимная связность пары кластеров <math>C_{i}, C{j}</math>

*<math>S_{EC_{(C_{i},C_{j})}}</math> - абсолютное взаимное сходство пары кластеров <math>C_{i}, C{j}</math>. Подсчитывается как среднее сходство между соединенными вершинами, принадлежащими <math>C{i}</math> и <math>C{j}</math> соответственно. Соединения обусловлены разбиением общего графа, полученного на первом этапе алгоритма.

*<math> RC_{(C_{i},C_{j})}= \frac{S_{EC_{(C_{i},C_{j})}}}{\frac{|C_{i}|}{|C_{i}+C_{j}|}*S_{EC_{(C_{i})}}+\frac{|C_{i}|}{|C_{i}+C_{j}|}*S_{EC_{(C_{j})}}}</math> - относительное взаимное сходство пары кластеров <math>C_{i}, C{j}</math>. Определяется как абсолютное сходство между этой парой кластеров, нормализованное с учетом их внутреннего сходства.

'''Первый этап'''

На первом этапе, согласно графо-ориентированному подходу, происходит построение графа <math>G = (V, E)</math> на матрице сходства объектов по принципу k ближайших соседей. Две вершины такого графа соединяет ребро, если объект, соответствующий любой из этих вершин попадает в число k наиболее близких объектов для объекта, соответствующего другой вершине из данной пары.
[[Файл:Снимок chameleon.PNG]]

'''Второй этап'''

Алгоритм разделяет полученный граф на множество сравнительно малых подграфов <math>K= \{K_{i}\}</math>. Разделение происходит последовательно. На каждом шаге выбирается подграф, содержащий наибольшее число вершин. Этот граф разделяется на два подграфа так, что разделитель ребер графа минимален и каждый из получаемых подграфов содержит не менее 25 % вершин исходного графа. Процесс разделения останавливается, когда наибольший подграф содержит меньше некоторого заданного числа вершин. Обычно величина этого параметра задается равной значению от 1 до 5 % от числа объектов. Полученное множество связных графов считается множеством начальных кластеров, на котором требуется провести последовательное иерархическое объединение.

'''Третий этап'''

Третий этап заключается в итеративном преобразовании множества подграфов <math>K= \{K_{i}\}</math> в множество кластеров <math>C = \{C_{i}\}</math>. Алгоритм осуществляет агломеративную иерархическую кластеризацию на основании показателей <math>EC_{(C_{i},C_{j})}</math>, <math>S_{EC_{(C_{i},C_{j})}}</math>, <math>RI_{(C_{i},C_{j})} </math>, <math> RC_{(C_{i},C_{j})}</math>. Существует две стратегии анализа показателей сходства. Первая подразумевает наличие некоторых пороговых значений <math>T_{RI}</math> и <math>T_{RC}</math>. В соответствии с этой стратегией, алгоритм для каждого кластера <math>C_{i}</math> проверяет, отвечают ли смежные (наиболее близкие) ему кластеры условиям:

*<math>RI_{(C_{i},C_{j})} \geqslant T_{RI}</math>

*<math>RC_{(C_{i},C_{j})} \geqslant T_{RC}</math>

Если более одного смежного кластера отвечает этим условиям, то алгоритм выбирает для объединения наиболее связный кластер (граф), то есть такой кластер <math>C_{j}</math>, с которым у кластера <math>C_{i}</math> получается наибольшая абсолютная взаимная связность. По завершению прохода по всем кластерам, созданные таким образом пары объединяются. Параметры <math>T_{RI}</math> и <math>T_{RC}</math> могут использоваться для изменения характеристик получаемых кластеров.

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

<math>RI_{(C_{i},C_{j})}*RC_{(C_{i},C_{j})}^\alpha</math>,

где <math>\alpha</math> выбирается пользователем. Если <math>\alpha > 1 </math>, то алгоритм придает большее значение относительному взаимному сходству, а если <math>\alpha < 1 </math>, то большее значение имеет относительная взаимная связность.

''Вычисляемые данные'':

<math>U = (u_1, u_2, ..., u_n)</math> - n-мерный вектор, где <math>u_i \in N_{[C]}</math> - порядковый номер кластера, к которому принадлежит вершина i исходного множества V.

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

Алгоритм имеет три вычислительных ядра, по одному на каждый этап.

На первом этапе вычислительным ядром является процесс нахождения <math>k</math> ближайших соседей для каждой вершины, который заключается в анализе матрицы расстояний.

На втором этапе вычислительным ядром является процесс поиска подходящего разбиения очередного подграфа на два графа с минимизацией разделителя ребер графа.

На третьем этапе вычислительным ядром является расчет величин <math>EC_{(C_{i},C_{j})}</math>, <math>S_{EC_{(C_{i},C_{j})}}</math>, <math>RI_{(C_{i},C_{j})} </math>, <math> RC_{(C_{i},C_{j})}</math> для каждой пары смежных кластеров.

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

Как уже рассказывалось ранее, алгоритм включает в себя три основных этапа, каждый из которых, по сути, является отдельным алгоритмом. Этапы выполняются последовательно относительно друг друга.

Макрооперация на первом этапе - процедура нахождения <math>k</math> ближайших соседей, на втором - процедура разбиения наибольшего подграфа на два графа, на третьем - процедура вычисления показателей сходства, на основе которых принимается решение о слиянии подграфов в кластер.

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

'''Первый этап'''
<nowiki><source lang=int n; //количество вершин
int k; //количество соседей
int A[n][n] //матрица расстояний
int D[k] //массив вершин-соседей
int E[n][n] //матрица ребер графа <math>G_{2} = (K, E_{2})</math>
for i=1 to n-1 do
{
for j=i+1 to n do
{
//заполняем массив вершин-соседей вставляя новые вершины, если они ближе, чем самая далекая из массива.
}
for j=0 to k do
{
//для каждой вершины соседа заполняем соответствующую ячейку из матрицы E[n][n] единицей
}

}
></nowiki>

'''Второй этап'''

1. Все связные подграфы в отсортированном порядке помещаются в список;
2. Берем наибольший элемент списка, вычисляем количество его вершин. Если число вершин > l, то идем в пункт 3. Иначе в пункт 5;
3. Разбиваем подграф на два подграфа таким образом, чтобы разделитель ребер графа был минимален и каждый из получаемых подграфов содержал не менее 25 % вершин исходного графа;
4. Добавляем полученные элементы в список подграфов таким образом, чтобы список оставался отсортированным. Идем в пункт 2;
5. Нашли искомое множество подграфов math>K = \{K_{i}\}</math>;
6. Создаем и заполняем матрицу матрицу расстояний для графа <math>G_{2} = (K, E_{2})</math>. Получаем искомый набор рёбер <math>E_{2}</math>.

'''Третий этап'''

1. Заводим два массива: а) массив кластеров C, полученных на предыдущем этапе, б) массив объединений кластеров F, которые мы будем получать на этом этапе;
2. Берем следующий кластер <math>C_{i}</math> (на первом шаге - первый). Если все кластеры просмотрены, идем в пункт 6;
3. Берем следующий кластер <math>C_{j}, i<>j</math>. Если все кластеры просмотрены, то идем в пункт 2;
4. Проверяем смежность <math>C_{i}</math> и <math>C_{j}</math>. Если не смежны, то возвращаемся в пункт 3. Если смежны, идем в пункт 5;
5. Рассчитываем показатели <math>RI_{(C_{i},C_{j})}</math> и <math> RC_{(C_{i},C_{j})}</math>. Проверяем, удовлетворяют ли найденные значения условиям:
*<math>RI_{(C_{i},C_{j})} \geqslant T_{RI}</math>
*<math>RC_{(C_{i},C_{j})} \geqslant T_{RC}</math>
Если нет, то идем в пункт 3. Иначе если смежность пары кластеров выше, чем у предыдущих найденных, то <math>F_{i}=j</math>. Идем в пункт 3;
6. Если в списке F есть хотя бы одна пара кластеров для слияния, то выполняем слияние, обновляем массив кластеров и массив объединений кластеров. Идем в пункт 2.

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

1) Для построения графа на основе метода k ближайших соседей для n вершин требуется <math>O(n log(n))</math> операций [3]; для наборов данных большой размерности эта величина составляет <math>O(n^2)</math> операций [4];

2) Для выделения множества сравнительно малых связных подграфов требуется <math>nm</math> операций, где <math>m</math> - количество подграфов, полученных на втором этапе алгоритма;

3) Формирование набора кластеров, на основе множества подграфов, полученных на предыдущем этапе, требует <math>m^2log(m)</math> операций.

Итого, для n вершин получаем последовательную сложность <math>O(n log(n)+nm+m^2log(m))</math>.

== Информационный граф ==
[[File:СК.png]]

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

Первый этап работы алгоритма можно распределить между <math>n</math> процессами. На вход каждому процессу подается своя вершина, далее происходит процедура поиска <math>k</math> ближайших соседей. Параллельная сложность составляет <math>O(n)</math>.

Второй и третий этапы можно распараллелить частично.

Второй этап распараллеливается путем подачи на вход свободному процессу очередного подграфа для разделения. Число итераций оценивается в <math>O(n log(n))</math>.

Третий этап делится на расчет показателей схожести и соединение подграфов в кластеры. Процесс расчета показателей можно распараллелить, подавая каждому процессу на вход пару подграфов. Сложность этого процесса оценивается как <math>m log(m)</math>. Соединение подграфов в кластеры выполняется последовательно, сложность процесса составляет <math>m^2 log(m)</math>

Таким образом получаем общую параллельную сложность алгоритма: <math>O(n+ n log(n) + m^2 log (m) + m log(m))</math>

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

1. Симметрическая матрица <math>A</math> расстояний между элементами данных размера <math>n\times n</math> с нулями на главной диагонали (<math>a_{ii}= 0, i = 1, \ldots, N</math>).

2. <math>k</math> - количество ближайших соседей для вершин (рекомендуемое значение <math>k</math> от 5 до 20 в зависимости от количества анализируемых объектов).

3. <math>l</math> - наименьшее число вершин, которое может содержать наибольший подкластер на 2-м этапе . Величина этого параметра варьируется от 1 до 5 % от общего числа объектов.

'''Объём входных данных'''

<math>\frac{n (n - 1)}{2}</math> (в силу симметричности и нулевой главной диагонали достаточно хранить только над/поддиагональные элементы).

'''Выходные данные'''

Вектор из <math>n</math> чисел <math>u_{1}, u_{2}, \ldots, u_{N}</math>, где <math>u_{i}</math> - целое число, соответствующее кластеру <math>i</math>-го объекта.

'''Объём выходных данных'''

<math>n</math>

== Свойства алгоритма ==
Соотношение последовательной и параллельной сложности на первом этапе является ''линейным'' для больших наборов данных и логарифмическим для n вершин. На втором этапе сложно оценить это соотношение - оно сильно зависит от параметров <math>k</math> и <math>l</math>. На третьем этапе соотношение равно <math>O(1)</math>

Алгоритм является недетерминированным. Хотя 1-й этап детерминирован, на 2-ом этапе могут быть найдены различные разбиения на подграфы, что повлияет и на итоговый результат работы алгоритма.

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

см. позднее

== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Последовательная реализация алгоритма доступна по ссылке [5].

CHAMELEON можно реализовать с использованием графовых библиотек METIS [6], hMETIS [7] и RANN [8].

Существует исследование, связанное с реализацией CHAMELEON посредством технологии OpenMP, с которым можно ознакомиться здесь [9].

Параллельных реализаций алгоритма CHAMELEON не найдено.

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

[2] http://studopedia.ru/7_41934_algoritm-dinamicheskoy-ierarhicheskoy-klasterizatsii-CHAMELEON.html

[3] J.H. Friedman, J.L. Bentley, and R.A. Finkel. An algorithm for ﬁnding best matches in logarithmic expected time. ACM Transactions on Mathematical Software, 3:209–226, 1977.

[4] S. Berchtold, C. Bohm, D. Keim, and H.-P. Kriegel. Cost model for nearest neighbor search in high dimensional data space. In Proc. of Symposium on Principles of Database Systems, Tucson, Arizona, 1997.

[5] http://www.codeforge.com/article/192925

[6] http://glaros.dtc.umn.edu/gkhome/metis/metis/overview

[7] http://glaros.dtc.umn.edu/gkhome/metis/hmetis/overview

[8] https://cran.r-project.org/web/packages/RANN/index.html

[9] http://research.ijcaonline.org/volume79/number8/pxc3891600.pdf

Участник:ЕкатеринаКозырева/Алгоритм динамической иерархической кластеризации CHAMELEON

2016-10-31T18:30:07Z

ЕкатеринаКозырева: /* Общее описание алгоритма */

{{algorithm
| name = Алгоритм динамической иерархической кластеризации CHAMELEON
| serial_complexity = <math>O(nm + n log n + m^2 log m)</math>
| input_data = <math>\frac{n (n - 1)}{2}</math>
| output_data = <math>n</math>
| pf_height = <math>O(n+ n log(n) + m^2 log (m) + m log(m))</math>
| pf_width = <math>O(n)</math>
}}

Автор описания [[Участник:ЕкатеринаКозырева|Е.А.Козырева]]
= Свойства и структура алгоритмов =

== Общее описание алгоритма ==
Алгоритм CHAMELEON был предложен в 1999 году тремя учеными из университета Миннесоты – George Karypis, Eui-Hong (Sam) Han и Vipin Kumar<ref>George Karypis, Eui-Hong (Sam) Han и Vipin Kumar, «Chameleon: Hierarchical Clustering Using Dynamic Modeling», 1999.</ref>.

Предназначен для решения задач кластеризации. Кластеризация (или кластерный анализ) — это задача разбиения множества объектов на группы, называемые кластерами. Внутри каждой группы должны оказаться «похожие» объекты, а объекты разных группы должны быть как можно более отличны.

CHAMELEON - это агломеративный иерархический алгоритм кластеризации, ключевой особенностью которого является то, что он учитывает и взаимную связность, и сходство при определении наиболее похожей пары подкластеров, основываясь на динамической модели. Это означает, что в процессе кластеризации два кластера объединяются, только если их относительная взаимная связность и относительное взаимное сходство являются высокими по отношению к внутренней взаимосвязанности кластеров и близости элементов внутри кластеров. Кроме того, CHAMELEON использует подход для моделирования степени взаимосвязанности и близости между каждой парой кластеров, который учитывает внутренние характеристики самих кластеров. Таким образом, он может автоматически адаптироваться к внутренним характеристикам объединяемых кластеров.

CHAMELEON находит кластеры в наборе данных с помощью трехфазного алгоритма. На первой фазе происходит построение графа, путём добавления рёбер по принципу k ближайших соседей. На второй фазе CHAMELEON группирует полученные элементы в множество относительно небольших подграфов. Во время третьей фазы применяется агломеративный иерархический алгоритм кластеризации, с помощью которого находятся естесственные кластеры путем многократного объединения подграфов, полученных на прошлом этапе.

[[File:Chameleon.png|1000px|thumb|center|Рисунок 1. Общая структура алгоритма CHAMELEON]]

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

''Исходные данные'':

* Множество из n точек <math>V= {v_{ij}}</math> в метрическом пространстве, которое задано симметрической матрицей расстояний <math>A</math> размера <math>n\times n</math>.
* <math>k</math> - количество ближайших соседей для вершин, <math>k \in N, k \leq n</math>.
* <math>l</math> - наименьшее число вершин, которое может содержать наибольший подграф на 2-м этапе, <math>l \in N, l \leq n</math>.

''Обозначения'':

* <math>G = (V, E)</math> - граф, полученный путём соединения каждой точки с её <math>k</math> ближайшими соседями.

* <math>K= \{K_{i}\}</math> - разбиение множества <math>V</math> на набор попарно непересекающихся связных подмножеств, полученное в результате выполнения второй фазы алгоритма.

* <math>G_{2} = (K, E_{2})</math> - взвешенный граф, вершинами которого являются получившиеся подграфы, а ребрами - количество ребер исходного графа, соединяющих соответствующие подграфы.

* <math>C = \{C_{i}\}</math> - итоговое разбиение множества вершин графа <math>G_{2}</math> на набор кластеров.

''Вспомогательные понятия''

*<math>EC_{(C_{i},C_{j})}</math> - абсолютная взаимная связность пары кластеров <math>C_{i}, C{j}</math>. Определяется как сумма весов ребер, соединяющих вершины, принадлежащие <math>C{i}</math> c вершинами из <math>C{j}</math>. Внутренняя связность <math>EC_{(C_{i},C_{i})}</math> вычисляется как сумма ребер, входящих в разделитель, разбивающий <math>C{i}</math> на два равных подграфа.

*<math>RI_{(C_{i},C_{j})} = \frac{|EC_{(C_{i},C_{j})}|}{(|EC_{C_{i}}|+|EC_{C_{j}}|)/2}</math> - относительная взаимная связность пары кластеров <math>C_{i}, C{j}</math>

*<math>S_{EC_{(C_{i},C_{j})}}</math> - абсолютное взаимное сходство пары кластеров <math>C_{i}, C{j}</math>. Подсчитывается как среднее сходство между соединенными вершинами, принадлежащими <math>C{i}</math> и <math>C{j}</math> соответственно. Соединения обусловлены разбиением общего графа, полученного на первом этапе алгоритма.

*<math> RC_{(C_{i},C_{j})}= \frac{S_{EC_{(C_{i},C_{j})}}}{\frac{|C_{i}|}{|C_{i}+C_{j}|}*S_{EC_{(C_{i})}}+\frac{|C_{i}|}{|C_{i}+C_{j}|}*S_{EC_{(C_{j})}}}</math> - относительное взаимное сходство пары кластеров <math>C_{i}, C{j}</math>. Определяется как абсолютное сходство между этой парой кластеров, нормализованное с учетом их внутреннего сходства.

'''Первый этап'''

На первом этапе, согласно графо-ориентированному подходу, происходит построение графа <math>G = (V, E)</math> на матрице сходства объектов по принципу k ближайших соседей. Две вершины такого графа соединяет ребро, если объект, соответствующий любой из этих вершин попадает в число k наиболее близких объектов для объекта, соответствующего другой вершине из данной пары.
[[Файл:Снимок chameleon.PNG]]

'''Второй этап'''

Алгоритм разделяет полученный граф на множество сравнительно малых подграфов <math>K= \{K_{i}\}</math>. Разделение происходит последовательно. На каждом шаге выбирается подграф, содержащий наибольшее число вершин. Этот граф разделяется на два подграфа так, что разделитель ребер графа минимален и каждый из получаемых подграфов содержит не менее 25 % вершин исходного графа. Процесс разделения останавливается, когда наибольший подграф содержит меньше некоторого заданного числа вершин. Обычно величина этого параметра задается равной значению от 1 до 5 % от числа объектов. Полученное множество связных графов считается множеством начальных кластеров, на котором требуется провести последовательное иерархическое объединение.

'''Третий этап'''

Третий этап заключается в итеративном преобразовании множества подграфов <math>K= \{K_{i}\}</math> в множество кластеров <math>C = \{C_{i}\}</math>. Алгоритм осуществляет агломеративную иерархическую кластеризацию на основании показателей <math>EC_{(C_{i},C_{j})}</math>, <math>S_{EC_{(C_{i},C_{j})}}</math>, <math>RI_{(C_{i},C_{j})} </math>, <math> RC_{(C_{i},C_{j})}</math>. Существует две стратегии анализа показателей сходства. Первая подразумевает наличие некоторых пороговых значений <math>T_{RI}</math> и <math>T_{RC}</math>. В соответствии с этой стратегией, алгоритм для каждого кластера <math>C_{i}</math> проверяет, отвечают ли смежные (наиболее близкие) ему кластеры условиям:

*<math>RI_{(C_{i},C_{j})} \geqslant T_{RI}</math>

*<math>RC_{(C_{i},C_{j})} \geqslant T_{RC}</math>

Если более одного смежного кластера отвечает этим условиям, то алгоритм выбирает для объединения наиболее связный кластер (граф), то есть такой кластер <math>C_{j}</math>, с которым у кластера <math>C_{i}</math> получается наибольшая абсолютная взаимная связность. По завершению прохода по всем кластерам, созданные таким образом пары объединяются. Параметры <math>T_{RI}</math> и <math>T_{RC}</math> могут использоваться для изменения характеристик получаемых кластеров.

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

<math>RI_{(C_{i},C_{j})}*RC_{(C_{i},C_{j})}^\alpha</math>,

где <math>\alpha</math> выбирается пользователем. Если <math>\alpha > 1 </math>, то алгоритм придает большее значение относительному взаимному сходству, а если <math>\alpha < 1 </math>, то большее значение имеет относительная взаимная связность.

''Вычисляемые данные'':

<math>U = (u_1, u_2, ..., u_n)</math> - n-мерный вектор, где <math>u_i \in N_{[C]}</math> - порядковый номер кластера, к которому принадлежит вершина i исходного множества V.

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

Алгоритм имеет три вычислительных ядра, по одному на каждый этап.

На первом этапе вычислительным ядром является процесс нахождения <math>k</math> ближайших соседей для каждой вершины, который заключается в анализе матрицы расстояний.

На втором этапе вычислительным ядром является процесс поиска подходящего разбиения очередного подграфа на два графа с минимизацией разделителя ребер графа.

На третьем этапе вычислительным ядром является расчет величин <math>EC_{(C_{i},C_{j})}</math>, <math>S_{EC_{(C_{i},C_{j})}}</math>, <math>RI_{(C_{i},C_{j})} </math>, <math> RC_{(C_{i},C_{j})}</math> для каждой пары смежных кластеров.

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

Как уже рассказывалось ранее, алгоритм включает в себя три основных этапа, каждый из которых, по сути, является отдельным алгоритмом. Этапы выполняются последовательно относительно друг друга.

Макрооперация на первом этапе - процедура нахождения <math>k</math> ближайших соседей, на втором - процедура разбиения наибольшего подграфа на два графа, на третьем - процедура вычисления показателей сходства, на основе которых принимается решение о слиянии подграфов в кластер.

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

'''Первый этап'''
int n; //количество вершин
int k; //количество соседей
int A[n][n] //матрица расстояний
int D[k] //массив вершин-соседей
int E[n][n] //матрица ребер графа <math>G_{2} = (K, E_{2})</math>
for i=1 to n-1 do
{
for j=i+1 to n do
{
//заполняем массив вершин-соседей вставляя новые вершины, если они ближе, чем самая далекая из массива.
}
for j=0 to k do
{
//для каждой вершины соседа заполняем соответствующую ячейку из матрицы E[n][n] единицей
}

}

'''Второй этап'''

1. Все связные подграфы в отсортированном порядке помещаются в список;
2. Берем наибольший элемент списка, вычисляем количество его вершин. Если число вершин > l, то идем в пункт 3. Иначе в пункт 5;
3. Разбиваем подграф на два подграфа таким образом, чтобы разделитель ребер графа был минимален и каждый из получаемых подграфов содержал не менее 25 % вершин исходного графа;
4. Добавляем полученные элементы в список подграфов таким образом, чтобы список оставался отсортированным. Идем в пункт 2;
5. Нашли искомое множество подграфов math>K = \{K_{i}\}</math>;
6. Создаем и заполняем матрицу матрицу расстояний для графа <math>G_{2} = (K, E_{2})</math>. Получаем искомый набор рёбер <math>E_{2}</math>.

'''Третий этап'''

1. Заводим два массива: а) массив кластеров C, полученных на предыдущем этапе, б) массив объединений кластеров F, которые мы будем получать на этом этапе;
2. Берем следующий кластер <math>C_{i}</math> (на первом шаге - первый). Если все кластеры просмотрены, идем в пункт 6;
3. Берем следующий кластер <math>C_{j}, i<>j</math>. Если все кластеры просмотрены, то идем в пункт 2;
4. Проверяем смежность <math>C_{i}</math> и <math>C_{j}</math>. Если не смежны, то возвращаемся в пункт 3. Если смежны, идем в пункт 5;
5. Рассчитываем показатели <math>RI_{(C_{i},C_{j})}</math> и <math> RC_{(C_{i},C_{j})}</math>. Проверяем, удовлетворяют ли найденные значения условиям:
*<math>RI_{(C_{i},C_{j})} \geqslant T_{RI}</math>
*<math>RC_{(C_{i},C_{j})} \geqslant T_{RC}</math>
Если нет, то идем в пункт 3. Иначе если смежность пары кластеров выше, чем у предыдущих найденных, то <math>F_{i}=j</math>. Идем в пункт 3;
6. Если в списке F есть хотя бы одна пара кластеров для слияния, то выполняем слияние, обновляем массив кластеров и массив объединений кластеров. Идем в пункт 2.

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

1) Для построения графа на основе метода k ближайших соседей для n вершин требуется <math>O(n log(n))</math> операций [3]; для наборов данных большой размерности эта величина составляет <math>O(n^2)</math> операций [4];

2) Для выделения множества сравнительно малых связных подграфов требуется <math>nm</math> операций, где <math>m</math> - количество подграфов, полученных на втором этапе алгоритма;

3) Формирование набора кластеров, на основе множества подграфов, полученных на предыдущем этапе, требует <math>m^2log(m)</math> операций.

Итого, для n вершин получаем последовательную сложность <math>O(n log(n)+nm+m^2log(m))</math>.

== Информационный граф ==
[[File:СК.png]]

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

Первый этап работы алгоритма можно распределить между <math>n</math> процессами. На вход каждому процессу подается своя вершина, далее происходит процедура поиска <math>k</math> ближайших соседей. Параллельная сложность составляет <math>O(n)</math>.

Второй и третий этапы можно распараллелить частично.

Второй этап распараллеливается путем подачи на вход свободному процессу очередного подграфа для разделения. Число итераций оценивается в <math>O(n log(n))</math>.

Третий этап делится на расчет показателей схожести и соединение подграфов в кластеры. Процесс расчета показателей можно распараллелить, подавая каждому процессу на вход пару подграфов. Сложность этого процесса оценивается как <math>m log(m)</math>. Соединение подграфов в кластеры выполняется последовательно, сложность процесса составляет <math>m^2 log(m)</math>

Таким образом получаем общую параллельную сложность алгоритма: <math>O(n+ n log(n) + m^2 log (m) + m log(m))</math>

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

1. Симметрическая матрица <math>A</math> расстояний между элементами данных размера <math>n\times n</math> с нулями на главной диагонали (<math>a_{ii}= 0, i = 1, \ldots, N</math>).

2. <math>k</math> - количество ближайших соседей для вершин (рекомендуемое значение <math>k</math> от 5 до 20 в зависимости от количества анализируемых объектов).

3. <math>l</math> - наименьшее число вершин, которое может содержать наибольший подкластер на 2-м этапе . Величина этого параметра варьируется от 1 до 5 % от общего числа объектов.

'''Объём входных данных'''

<math>\frac{n (n - 1)}{2}</math> (в силу симметричности и нулевой главной диагонали достаточно хранить только над/поддиагональные элементы).

'''Выходные данные'''

Вектор из <math>n</math> чисел <math>u_{1}, u_{2}, \ldots, u_{N}</math>, где <math>u_{i}</math> - целое число, соответствующее кластеру <math>i</math>-го объекта.

'''Объём выходных данных'''

<math>n</math>

== Свойства алгоритма ==
Соотношение последовательной и параллельной сложности на первом этапе является ''линейным'' для больших наборов данных и логарифмическим для n вершин. На втором этапе сложно оценить это соотношение - оно сильно зависит от параметров <math>k</math> и <math>l</math>. На третьем этапе соотношение равно <math>O(1)</math>

Алгоритм является недетерминированным. Хотя 1-й этап детерминирован, на 2-ом этапе могут быть найдены различные разбиения на подграфы, что повлияет и на итоговый результат работы алгоритма.

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

см. позднее

== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Последовательная реализация алгоритма доступна по ссылке [5].

CHAMELEON можно реализовать с использованием графовых библиотек METIS [6], hMETIS [7] и RANN [8].

Существует исследование, связанное с реализацией CHAMELEON посредством технологии OpenMP, с которым можно ознакомиться здесь [9].

Параллельных реализаций алгоритма CHAMELEON не найдено.

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

[2] http://studopedia.ru/7_41934_algoritm-dinamicheskoy-ierarhicheskoy-klasterizatsii-CHAMELEON.html

[3] J.H. Friedman, J.L. Bentley, and R.A. Finkel. An algorithm for ﬁnding best matches in logarithmic expected time. ACM Transactions on Mathematical Software, 3:209–226, 1977.

[4] S. Berchtold, C. Bohm, D. Keim, and H.-P. Kriegel. Cost model for nearest neighbor search in high dimensional data space. In Proc. of Symposium on Principles of Database Systems, Tucson, Arizona, 1997.

[5] http://www.codeforge.com/article/192925

[6] http://glaros.dtc.umn.edu/gkhome/metis/metis/overview

[7] http://glaros.dtc.umn.edu/gkhome/metis/hmetis/overview

[8] https://cran.r-project.org/web/packages/RANN/index.html

[9] http://research.ijcaonline.org/volume79/number8/pxc3891600.pdf

Обсуждение участника:ЕкатеринаКозырева

2016-10-31T18:26:53Z

== Замечания к [[Участник:ЕкатеринаКозырева/Алгоритм_динамической_иерархической_кластеризации_CHAMELEON]] ==

+1) отсутствует оценка высоты и ширины ЯПФ параллельного алгоритма во врезке в начале статьи

2) требуется какая-то подпись или ссылка на рисунок в п 1.1

3) подпись к рисунку 1.2 должны быть выполнена средствами разметки, а не на самой картинке

4) для оформления (псевдо) кода следует использовать тег <nowiki><source lang="..."></nowiki>

5) отсутствует оценка вычислительной мощности алгоритма в п 1.10

+6) пункты 2.1 и 2.2 должны быть 2.4 и 2.7, согласно формату описания [[Структура_описания_свойств_алгоритмов]]

7) список литературы оформлен неправильно - см. как сделано в [[Разложение_Холецкого_(метод_квадратного_корня)]]

Участник:ЕкатеринаКозырева/Алгоритм динамической иерархической кластеризации CHAMELEON

2016-10-31T18:26:16Z

ЕкатеринаКозырева: /* Литература */

{{algorithm
| name = Алгоритм динамической иерархической кластеризации CHAMELEON
| serial_complexity = <math>O(nm + n log n + m^2 log m)</math>
| input_data = <math>\frac{n (n - 1)}{2}</math>
| output_data = <math>n</math>
| pf_height = <math>O(n+ n log(n) + m^2 log (m) + m log(m))</math>
| pf_width = <math>O(n)</math>
}}

Автор описания [[Участник:ЕкатеринаКозырева|Е.А.Козырева]]
= Свойства и структура алгоритмов =

== Общее описание алгоритма ==
Алгоритм CHAMELEON был предложен в 1999 году тремя учеными из университета Миннесоты – George Karypis, Eui-Hong (Sam) Han и Vipin Kumar<ref>George Karypis, Eui-Hong (Sam) Han и Vipin Kumar, «Chameleon: Hierarchical Clustering Using Dynamic Modeling», 1999.</ref>.

Предназначен для решения задач кластеризации. Кластеризация (или кластерный анализ) — это задача разбиения множества объектов на группы, называемые кластерами. Внутри каждой группы должны оказаться «похожие» объекты, а объекты разных группы должны быть как можно более отличны.

CHAMELEON - это агломеративный иерархический алгоритм кластеризации, ключевой особенностью которого является то, что он учитывает и взаимную связность, и сходство при определении наиболее похожей пары подкластеров, основываясь на динамической модели. Это означает, что в процессе кластеризации два кластера объединяются, только если их относительная взаимная связность и относительное взаимное сходство являются высокими по отношению к внутренней взаимосвязанности кластеров и близости элементов внутри кластеров. Кроме того, CHAMELEON использует подход для моделирования степени взаимосвязанности и близости между каждой парой кластеров, который учитывает внутренние характеристики самих кластеров. Таким образом, он может автоматически адаптироваться к внутренним характеристикам объединяемых кластеров.

CHAMELEON находит кластеры в наборе данных с помощью трехфазного алгоритма. На первой фазе происходит построение графа, путём добавления рёбер по принципу k ближайших соседей. На второй фазе CHAMELEON группирует полученные элементы в множество относительно небольших подграфов. Во время третьей фазы применяется агломеративный иерархический алгоритм кластеризации, с помощью которого находятся естесственные кластеры путем многократного объединения подграфов, полученных на прошлом этапе.

[[File:Chameleon.png]]

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

''Исходные данные'':

* Множество из n точек <math>V= {v_{ij}}</math> в метрическом пространстве, которое задано симметрической матрицей расстояний <math>A</math> размера <math>n\times n</math>.
* <math>k</math> - количество ближайших соседей для вершин, <math>k \in N, k \leq n</math>.
* <math>l</math> - наименьшее число вершин, которое может содержать наибольший подграф на 2-м этапе, <math>l \in N, l \leq n</math>.

''Обозначения'':

* <math>G = (V, E)</math> - граф, полученный путём соединения каждой точки с её <math>k</math> ближайшими соседями.

* <math>K= \{K_{i}\}</math> - разбиение множества <math>V</math> на набор попарно непересекающихся связных подмножеств, полученное в результате выполнения второй фазы алгоритма.

* <math>G_{2} = (K, E_{2})</math> - взвешенный граф, вершинами которого являются получившиеся подграфы, а ребрами - количество ребер исходного графа, соединяющих соответствующие подграфы.

* <math>C = \{C_{i}\}</math> - итоговое разбиение множества вершин графа <math>G_{2}</math> на набор кластеров.

''Вспомогательные понятия''

*<math>EC_{(C_{i},C_{j})}</math> - абсолютная взаимная связность пары кластеров <math>C_{i}, C{j}</math>. Определяется как сумма весов ребер, соединяющих вершины, принадлежащие <math>C{i}</math> c вершинами из <math>C{j}</math>. Внутренняя связность <math>EC_{(C_{i},C_{i})}</math> вычисляется как сумма ребер, входящих в разделитель, разбивающий <math>C{i}</math> на два равных подграфа.

*<math>RI_{(C_{i},C_{j})} = \frac{|EC_{(C_{i},C_{j})}|}{(|EC_{C_{i}}|+|EC_{C_{j}}|)/2}</math> - относительная взаимная связность пары кластеров <math>C_{i}, C{j}</math>

*<math>S_{EC_{(C_{i},C_{j})}}</math> - абсолютное взаимное сходство пары кластеров <math>C_{i}, C{j}</math>. Подсчитывается как среднее сходство между соединенными вершинами, принадлежащими <math>C{i}</math> и <math>C{j}</math> соответственно. Соединения обусловлены разбиением общего графа, полученного на первом этапе алгоритма.

*<math> RC_{(C_{i},C_{j})}= \frac{S_{EC_{(C_{i},C_{j})}}}{\frac{|C_{i}|}{|C_{i}+C_{j}|}*S_{EC_{(C_{i})}}+\frac{|C_{i}|}{|C_{i}+C_{j}|}*S_{EC_{(C_{j})}}}</math> - относительное взаимное сходство пары кластеров <math>C_{i}, C{j}</math>. Определяется как абсолютное сходство между этой парой кластеров, нормализованное с учетом их внутреннего сходства.

'''Первый этап'''

На первом этапе, согласно графо-ориентированному подходу, происходит построение графа <math>G = (V, E)</math> на матрице сходства объектов по принципу k ближайших соседей. Две вершины такого графа соединяет ребро, если объект, соответствующий любой из этих вершин попадает в число k наиболее близких объектов для объекта, соответствующего другой вершине из данной пары.
[[Файл:Снимок chameleon.PNG]]

'''Второй этап'''

Алгоритм разделяет полученный граф на множество сравнительно малых подграфов <math>K= \{K_{i}\}</math>. Разделение происходит последовательно. На каждом шаге выбирается подграф, содержащий наибольшее число вершин. Этот граф разделяется на два подграфа так, что разделитель ребер графа минимален и каждый из получаемых подграфов содержит не менее 25 % вершин исходного графа. Процесс разделения останавливается, когда наибольший подграф содержит меньше некоторого заданного числа вершин. Обычно величина этого параметра задается равной значению от 1 до 5 % от числа объектов. Полученное множество связных графов считается множеством начальных кластеров, на котором требуется провести последовательное иерархическое объединение.

'''Третий этап'''

Третий этап заключается в итеративном преобразовании множества подграфов <math>K= \{K_{i}\}</math> в множество кластеров <math>C = \{C_{i}\}</math>. Алгоритм осуществляет агломеративную иерархическую кластеризацию на основании показателей <math>EC_{(C_{i},C_{j})}</math>, <math>S_{EC_{(C_{i},C_{j})}}</math>, <math>RI_{(C_{i},C_{j})} </math>, <math> RC_{(C_{i},C_{j})}</math>. Существует две стратегии анализа показателей сходства. Первая подразумевает наличие некоторых пороговых значений <math>T_{RI}</math> и <math>T_{RC}</math>. В соответствии с этой стратегией, алгоритм для каждого кластера <math>C_{i}</math> проверяет, отвечают ли смежные (наиболее близкие) ему кластеры условиям:

*<math>RI_{(C_{i},C_{j})} \geqslant T_{RI}</math>

*<math>RC_{(C_{i},C_{j})} \geqslant T_{RC}</math>

Если более одного смежного кластера отвечает этим условиям, то алгоритм выбирает для объединения наиболее связный кластер (граф), то есть такой кластер <math>C_{j}</math>, с которым у кластера <math>C_{i}</math> получается наибольшая абсолютная взаимная связность. По завершению прохода по всем кластерам, созданные таким образом пары объединяются. Параметры <math>T_{RI}</math> и <math>T_{RC}</math> могут использоваться для изменения характеристик получаемых кластеров.

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

<math>RI_{(C_{i},C_{j})}*RC_{(C_{i},C_{j})}^\alpha</math>,

где <math>\alpha</math> выбирается пользователем. Если <math>\alpha > 1 </math>, то алгоритм придает большее значение относительному взаимному сходству, а если <math>\alpha < 1 </math>, то большее значение имеет относительная взаимная связность.

''Вычисляемые данные'':

<math>U = (u_1, u_2, ..., u_n)</math> - n-мерный вектор, где <math>u_i \in N_{[C]}</math> - порядковый номер кластера, к которому принадлежит вершина i исходного множества V.

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

Алгоритм имеет три вычислительных ядра, по одному на каждый этап.

На первом этапе вычислительным ядром является процесс нахождения <math>k</math> ближайших соседей для каждой вершины, который заключается в анализе матрицы расстояний.

На втором этапе вычислительным ядром является процесс поиска подходящего разбиения очередного подграфа на два графа с минимизацией разделителя ребер графа.

На третьем этапе вычислительным ядром является расчет величин <math>EC_{(C_{i},C_{j})}</math>, <math>S_{EC_{(C_{i},C_{j})}}</math>, <math>RI_{(C_{i},C_{j})} </math>, <math> RC_{(C_{i},C_{j})}</math> для каждой пары смежных кластеров.

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

Как уже рассказывалось ранее, алгоритм включает в себя три основных этапа, каждый из которых, по сути, является отдельным алгоритмом. Этапы выполняются последовательно относительно друг друга.

Макрооперация на первом этапе - процедура нахождения <math>k</math> ближайших соседей, на втором - процедура разбиения наибольшего подграфа на два графа, на третьем - процедура вычисления показателей сходства, на основе которых принимается решение о слиянии подграфов в кластер.

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

'''Первый этап'''
int n; //количество вершин
int k; //количество соседей
int A[n][n] //матрица расстояний
int D[k] //массив вершин-соседей
int E[n][n] //матрица ребер графа <math>G_{2} = (K, E_{2})</math>
for i=1 to n-1 do
{
for j=i+1 to n do
{
//заполняем массив вершин-соседей вставляя новые вершины, если они ближе, чем самая далекая из массива.
}
for j=0 to k do
{
//для каждой вершины соседа заполняем соответствующую ячейку из матрицы E[n][n] единицей
}

}

'''Второй этап'''

1. Все связные подграфы в отсортированном порядке помещаются в список;
2. Берем наибольший элемент списка, вычисляем количество его вершин. Если число вершин > l, то идем в пункт 3. Иначе в пункт 5;
3. Разбиваем подграф на два подграфа таким образом, чтобы разделитель ребер графа был минимален и каждый из получаемых подграфов содержал не менее 25 % вершин исходного графа;
4. Добавляем полученные элементы в список подграфов таким образом, чтобы список оставался отсортированным. Идем в пункт 2;
5. Нашли искомое множество подграфов math>K = \{K_{i}\}</math>;
6. Создаем и заполняем матрицу матрицу расстояний для графа <math>G_{2} = (K, E_{2})</math>. Получаем искомый набор рёбер <math>E_{2}</math>.

'''Третий этап'''

1. Заводим два массива: а) массив кластеров C, полученных на предыдущем этапе, б) массив объединений кластеров F, которые мы будем получать на этом этапе;
2. Берем следующий кластер <math>C_{i}</math> (на первом шаге - первый). Если все кластеры просмотрены, идем в пункт 6;
3. Берем следующий кластер <math>C_{j}, i<>j</math>. Если все кластеры просмотрены, то идем в пункт 2;
4. Проверяем смежность <math>C_{i}</math> и <math>C_{j}</math>. Если не смежны, то возвращаемся в пункт 3. Если смежны, идем в пункт 5;
5. Рассчитываем показатели <math>RI_{(C_{i},C_{j})}</math> и <math> RC_{(C_{i},C_{j})}</math>. Проверяем, удовлетворяют ли найденные значения условиям:
*<math>RI_{(C_{i},C_{j})} \geqslant T_{RI}</math>
*<math>RC_{(C_{i},C_{j})} \geqslant T_{RC}</math>
Если нет, то идем в пункт 3. Иначе если смежность пары кластеров выше, чем у предыдущих найденных, то <math>F_{i}=j</math>. Идем в пункт 3;
6. Если в списке F есть хотя бы одна пара кластеров для слияния, то выполняем слияние, обновляем массив кластеров и массив объединений кластеров. Идем в пункт 2.

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

1) Для построения графа на основе метода k ближайших соседей для n вершин требуется <math>O(n log(n))</math> операций [3]; для наборов данных большой размерности эта величина составляет <math>O(n^2)</math> операций [4];

2) Для выделения множества сравнительно малых связных подграфов требуется <math>nm</math> операций, где <math>m</math> - количество подграфов, полученных на втором этапе алгоритма;

3) Формирование набора кластеров, на основе множества подграфов, полученных на предыдущем этапе, требует <math>m^2log(m)</math> операций.

Итого, для n вершин получаем последовательную сложность <math>O(n log(n)+nm+m^2log(m))</math>.

== Информационный граф ==
[[File:СК.png]]

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

Первый этап работы алгоритма можно распределить между <math>n</math> процессами. На вход каждому процессу подается своя вершина, далее происходит процедура поиска <math>k</math> ближайших соседей. Параллельная сложность составляет <math>O(n)</math>.

Второй и третий этапы можно распараллелить частично.

Второй этап распараллеливается путем подачи на вход свободному процессу очередного подграфа для разделения. Число итераций оценивается в <math>O(n log(n))</math>.

Третий этап делится на расчет показателей схожести и соединение подграфов в кластеры. Процесс расчета показателей можно распараллелить, подавая каждому процессу на вход пару подграфов. Сложность этого процесса оценивается как <math>m log(m)</math>. Соединение подграфов в кластеры выполняется последовательно, сложность процесса составляет <math>m^2 log(m)</math>

Таким образом получаем общую параллельную сложность алгоритма: <math>O(n+ n log(n) + m^2 log (m) + m log(m))</math>

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

1. Симметрическая матрица <math>A</math> расстояний между элементами данных размера <math>n\times n</math> с нулями на главной диагонали (<math>a_{ii}= 0, i = 1, \ldots, N</math>).

2. <math>k</math> - количество ближайших соседей для вершин (рекомендуемое значение <math>k</math> от 5 до 20 в зависимости от количества анализируемых объектов).

3. <math>l</math> - наименьшее число вершин, которое может содержать наибольший подкластер на 2-м этапе . Величина этого параметра варьируется от 1 до 5 % от общего числа объектов.

'''Объём входных данных'''

<math>\frac{n (n - 1)}{2}</math> (в силу симметричности и нулевой главной диагонали достаточно хранить только над/поддиагональные элементы).

'''Выходные данные'''

Вектор из <math>n</math> чисел <math>u_{1}, u_{2}, \ldots, u_{N}</math>, где <math>u_{i}</math> - целое число, соответствующее кластеру <math>i</math>-го объекта.

'''Объём выходных данных'''

<math>n</math>

== Свойства алгоритма ==
Соотношение последовательной и параллельной сложности на первом этапе является ''линейным'' для больших наборов данных и логарифмическим для n вершин. На втором этапе сложно оценить это соотношение - оно сильно зависит от параметров <math>k</math> и <math>l</math>. На третьем этапе соотношение равно <math>O(1)</math>

Алгоритм является недетерминированным. Хотя 1-й этап детерминирован, на 2-ом этапе могут быть найдены различные разбиения на подграфы, что повлияет и на итоговый результат работы алгоритма.

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

см. позднее

== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Последовательная реализация алгоритма доступна по ссылке [5].

CHAMELEON можно реализовать с использованием графовых библиотек METIS [6], hMETIS [7] и RANN [8].

Существует исследование, связанное с реализацией CHAMELEON посредством технологии OpenMP, с которым можно ознакомиться здесь [9].

Параллельных реализаций алгоритма CHAMELEON не найдено.

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

[2] http://studopedia.ru/7_41934_algoritm-dinamicheskoy-ierarhicheskoy-klasterizatsii-CHAMELEON.html

[3] J.H. Friedman, J.L. Bentley, and R.A. Finkel. An algorithm for ﬁnding best matches in logarithmic expected time. ACM Transactions on Mathematical Software, 3:209–226, 1977.

[4] S. Berchtold, C. Bohm, D. Keim, and H.-P. Kriegel. Cost model for nearest neighbor search in high dimensional data space. In Proc. of Symposium on Principles of Database Systems, Tucson, Arizona, 1997.

[5] http://www.codeforge.com/article/192925

[6] http://glaros.dtc.umn.edu/gkhome/metis/metis/overview

[7] http://glaros.dtc.umn.edu/gkhome/metis/hmetis/overview

[8] https://cran.r-project.org/web/packages/RANN/index.html

[9] http://research.ijcaonline.org/volume79/number8/pxc3891600.pdf

Участник:ЕкатеринаКозырева/Алгоритм динамической иерархической кластеризации CHAMELEON

2016-10-31T18:25:56Z

ЕкатеринаКозырева: /* часть. Программная реализация алгоритма */

{{algorithm
| name = Алгоритм динамической иерархической кластеризации CHAMELEON
| serial_complexity = <math>O(nm + n log n + m^2 log m)</math>
| input_data = <math>\frac{n (n - 1)}{2}</math>
| output_data = <math>n</math>
| pf_height = <math>O(n+ n log(n) + m^2 log (m) + m log(m))</math>
| pf_width = <math>O(n)</math>
}}

Автор описания [[Участник:ЕкатеринаКозырева|Е.А.Козырева]]
= Свойства и структура алгоритмов =

== Общее описание алгоритма ==
Алгоритм CHAMELEON был предложен в 1999 году тремя учеными из университета Миннесоты – George Karypis, Eui-Hong (Sam) Han и Vipin Kumar<ref>George Karypis, Eui-Hong (Sam) Han и Vipin Kumar, «Chameleon: Hierarchical Clustering Using Dynamic Modeling», 1999.</ref>.

Предназначен для решения задач кластеризации. Кластеризация (или кластерный анализ) — это задача разбиения множества объектов на группы, называемые кластерами. Внутри каждой группы должны оказаться «похожие» объекты, а объекты разных группы должны быть как можно более отличны.

CHAMELEON - это агломеративный иерархический алгоритм кластеризации, ключевой особенностью которого является то, что он учитывает и взаимную связность, и сходство при определении наиболее похожей пары подкластеров, основываясь на динамической модели. Это означает, что в процессе кластеризации два кластера объединяются, только если их относительная взаимная связность и относительное взаимное сходство являются высокими по отношению к внутренней взаимосвязанности кластеров и близости элементов внутри кластеров. Кроме того, CHAMELEON использует подход для моделирования степени взаимосвязанности и близости между каждой парой кластеров, который учитывает внутренние характеристики самих кластеров. Таким образом, он может автоматически адаптироваться к внутренним характеристикам объединяемых кластеров.

CHAMELEON находит кластеры в наборе данных с помощью трехфазного алгоритма. На первой фазе происходит построение графа, путём добавления рёбер по принципу k ближайших соседей. На второй фазе CHAMELEON группирует полученные элементы в множество относительно небольших подграфов. Во время третьей фазы применяется агломеративный иерархический алгоритм кластеризации, с помощью которого находятся естесственные кластеры путем многократного объединения подграфов, полученных на прошлом этапе.

[[File:Chameleon.png]]

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

''Исходные данные'':

* Множество из n точек <math>V= {v_{ij}}</math> в метрическом пространстве, которое задано симметрической матрицей расстояний <math>A</math> размера <math>n\times n</math>.
* <math>k</math> - количество ближайших соседей для вершин, <math>k \in N, k \leq n</math>.
* <math>l</math> - наименьшее число вершин, которое может содержать наибольший подграф на 2-м этапе, <math>l \in N, l \leq n</math>.

''Обозначения'':

* <math>G = (V, E)</math> - граф, полученный путём соединения каждой точки с её <math>k</math> ближайшими соседями.

* <math>K= \{K_{i}\}</math> - разбиение множества <math>V</math> на набор попарно непересекающихся связных подмножеств, полученное в результате выполнения второй фазы алгоритма.

* <math>G_{2} = (K, E_{2})</math> - взвешенный граф, вершинами которого являются получившиеся подграфы, а ребрами - количество ребер исходного графа, соединяющих соответствующие подграфы.

* <math>C = \{C_{i}\}</math> - итоговое разбиение множества вершин графа <math>G_{2}</math> на набор кластеров.

''Вспомогательные понятия''

*<math>EC_{(C_{i},C_{j})}</math> - абсолютная взаимная связность пары кластеров <math>C_{i}, C{j}</math>. Определяется как сумма весов ребер, соединяющих вершины, принадлежащие <math>C{i}</math> c вершинами из <math>C{j}</math>. Внутренняя связность <math>EC_{(C_{i},C_{i})}</math> вычисляется как сумма ребер, входящих в разделитель, разбивающий <math>C{i}</math> на два равных подграфа.

*<math>RI_{(C_{i},C_{j})} = \frac{|EC_{(C_{i},C_{j})}|}{(|EC_{C_{i}}|+|EC_{C_{j}}|)/2}</math> - относительная взаимная связность пары кластеров <math>C_{i}, C{j}</math>

*<math>S_{EC_{(C_{i},C_{j})}}</math> - абсолютное взаимное сходство пары кластеров <math>C_{i}, C{j}</math>. Подсчитывается как среднее сходство между соединенными вершинами, принадлежащими <math>C{i}</math> и <math>C{j}</math> соответственно. Соединения обусловлены разбиением общего графа, полученного на первом этапе алгоритма.

*<math> RC_{(C_{i},C_{j})}= \frac{S_{EC_{(C_{i},C_{j})}}}{\frac{|C_{i}|}{|C_{i}+C_{j}|}*S_{EC_{(C_{i})}}+\frac{|C_{i}|}{|C_{i}+C_{j}|}*S_{EC_{(C_{j})}}}</math> - относительное взаимное сходство пары кластеров <math>C_{i}, C{j}</math>. Определяется как абсолютное сходство между этой парой кластеров, нормализованное с учетом их внутреннего сходства.

'''Первый этап'''

На первом этапе, согласно графо-ориентированному подходу, происходит построение графа <math>G = (V, E)</math> на матрице сходства объектов по принципу k ближайших соседей. Две вершины такого графа соединяет ребро, если объект, соответствующий любой из этих вершин попадает в число k наиболее близких объектов для объекта, соответствующего другой вершине из данной пары.
[[Файл:Снимок chameleon.PNG]]

'''Второй этап'''

Алгоритм разделяет полученный граф на множество сравнительно малых подграфов <math>K= \{K_{i}\}</math>. Разделение происходит последовательно. На каждом шаге выбирается подграф, содержащий наибольшее число вершин. Этот граф разделяется на два подграфа так, что разделитель ребер графа минимален и каждый из получаемых подграфов содержит не менее 25 % вершин исходного графа. Процесс разделения останавливается, когда наибольший подграф содержит меньше некоторого заданного числа вершин. Обычно величина этого параметра задается равной значению от 1 до 5 % от числа объектов. Полученное множество связных графов считается множеством начальных кластеров, на котором требуется провести последовательное иерархическое объединение.

'''Третий этап'''

Третий этап заключается в итеративном преобразовании множества подграфов <math>K= \{K_{i}\}</math> в множество кластеров <math>C = \{C_{i}\}</math>. Алгоритм осуществляет агломеративную иерархическую кластеризацию на основании показателей <math>EC_{(C_{i},C_{j})}</math>, <math>S_{EC_{(C_{i},C_{j})}}</math>, <math>RI_{(C_{i},C_{j})} </math>, <math> RC_{(C_{i},C_{j})}</math>. Существует две стратегии анализа показателей сходства. Первая подразумевает наличие некоторых пороговых значений <math>T_{RI}</math> и <math>T_{RC}</math>. В соответствии с этой стратегией, алгоритм для каждого кластера <math>C_{i}</math> проверяет, отвечают ли смежные (наиболее близкие) ему кластеры условиям:

*<math>RI_{(C_{i},C_{j})} \geqslant T_{RI}</math>

*<math>RC_{(C_{i},C_{j})} \geqslant T_{RC}</math>

Если более одного смежного кластера отвечает этим условиям, то алгоритм выбирает для объединения наиболее связный кластер (граф), то есть такой кластер <math>C_{j}</math>, с которым у кластера <math>C_{i}</math> получается наибольшая абсолютная взаимная связность. По завершению прохода по всем кластерам, созданные таким образом пары объединяются. Параметры <math>T_{RI}</math> и <math>T_{RC}</math> могут использоваться для изменения характеристик получаемых кластеров.

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

<math>RI_{(C_{i},C_{j})}*RC_{(C_{i},C_{j})}^\alpha</math>,

где <math>\alpha</math> выбирается пользователем. Если <math>\alpha > 1 </math>, то алгоритм придает большее значение относительному взаимному сходству, а если <math>\alpha < 1 </math>, то большее значение имеет относительная взаимная связность.

''Вычисляемые данные'':

<math>U = (u_1, u_2, ..., u_n)</math> - n-мерный вектор, где <math>u_i \in N_{[C]}</math> - порядковый номер кластера, к которому принадлежит вершина i исходного множества V.

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

Алгоритм имеет три вычислительных ядра, по одному на каждый этап.

На первом этапе вычислительным ядром является процесс нахождения <math>k</math> ближайших соседей для каждой вершины, который заключается в анализе матрицы расстояний.

На втором этапе вычислительным ядром является процесс поиска подходящего разбиения очередного подграфа на два графа с минимизацией разделителя ребер графа.

На третьем этапе вычислительным ядром является расчет величин <math>EC_{(C_{i},C_{j})}</math>, <math>S_{EC_{(C_{i},C_{j})}}</math>, <math>RI_{(C_{i},C_{j})} </math>, <math> RC_{(C_{i},C_{j})}</math> для каждой пары смежных кластеров.

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

Как уже рассказывалось ранее, алгоритм включает в себя три основных этапа, каждый из которых, по сути, является отдельным алгоритмом. Этапы выполняются последовательно относительно друг друга.

Макрооперация на первом этапе - процедура нахождения <math>k</math> ближайших соседей, на втором - процедура разбиения наибольшего подграфа на два графа, на третьем - процедура вычисления показателей сходства, на основе которых принимается решение о слиянии подграфов в кластер.

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

'''Первый этап'''
int n; //количество вершин
int k; //количество соседей
int A[n][n] //матрица расстояний
int D[k] //массив вершин-соседей
int E[n][n] //матрица ребер графа <math>G_{2} = (K, E_{2})</math>
for i=1 to n-1 do
{
for j=i+1 to n do
{
//заполняем массив вершин-соседей вставляя новые вершины, если они ближе, чем самая далекая из массива.
}
for j=0 to k do
{
//для каждой вершины соседа заполняем соответствующую ячейку из матрицы E[n][n] единицей
}

}

'''Второй этап'''

1. Все связные подграфы в отсортированном порядке помещаются в список;
2. Берем наибольший элемент списка, вычисляем количество его вершин. Если число вершин > l, то идем в пункт 3. Иначе в пункт 5;
3. Разбиваем подграф на два подграфа таким образом, чтобы разделитель ребер графа был минимален и каждый из получаемых подграфов содержал не менее 25 % вершин исходного графа;
4. Добавляем полученные элементы в список подграфов таким образом, чтобы список оставался отсортированным. Идем в пункт 2;
5. Нашли искомое множество подграфов math>K = \{K_{i}\}</math>;
6. Создаем и заполняем матрицу матрицу расстояний для графа <math>G_{2} = (K, E_{2})</math>. Получаем искомый набор рёбер <math>E_{2}</math>.

'''Третий этап'''

1. Заводим два массива: а) массив кластеров C, полученных на предыдущем этапе, б) массив объединений кластеров F, которые мы будем получать на этом этапе;
2. Берем следующий кластер <math>C_{i}</math> (на первом шаге - первый). Если все кластеры просмотрены, идем в пункт 6;
3. Берем следующий кластер <math>C_{j}, i<>j</math>. Если все кластеры просмотрены, то идем в пункт 2;
4. Проверяем смежность <math>C_{i}</math> и <math>C_{j}</math>. Если не смежны, то возвращаемся в пункт 3. Если смежны, идем в пункт 5;
5. Рассчитываем показатели <math>RI_{(C_{i},C_{j})}</math> и <math> RC_{(C_{i},C_{j})}</math>. Проверяем, удовлетворяют ли найденные значения условиям:
*<math>RI_{(C_{i},C_{j})} \geqslant T_{RI}</math>
*<math>RC_{(C_{i},C_{j})} \geqslant T_{RC}</math>
Если нет, то идем в пункт 3. Иначе если смежность пары кластеров выше, чем у предыдущих найденных, то <math>F_{i}=j</math>. Идем в пункт 3;
6. Если в списке F есть хотя бы одна пара кластеров для слияния, то выполняем слияние, обновляем массив кластеров и массив объединений кластеров. Идем в пункт 2.

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

1) Для построения графа на основе метода k ближайших соседей для n вершин требуется <math>O(n log(n))</math> операций [3]; для наборов данных большой размерности эта величина составляет <math>O(n^2)</math> операций [4];

2) Для выделения множества сравнительно малых связных подграфов требуется <math>nm</math> операций, где <math>m</math> - количество подграфов, полученных на втором этапе алгоритма;

3) Формирование набора кластеров, на основе множества подграфов, полученных на предыдущем этапе, требует <math>m^2log(m)</math> операций.

Итого, для n вершин получаем последовательную сложность <math>O(n log(n)+nm+m^2log(m))</math>.

== Информационный граф ==
[[File:СК.png]]

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

Первый этап работы алгоритма можно распределить между <math>n</math> процессами. На вход каждому процессу подается своя вершина, далее происходит процедура поиска <math>k</math> ближайших соседей. Параллельная сложность составляет <math>O(n)</math>.

Второй и третий этапы можно распараллелить частично.

Второй этап распараллеливается путем подачи на вход свободному процессу очередного подграфа для разделения. Число итераций оценивается в <math>O(n log(n))</math>.

Третий этап делится на расчет показателей схожести и соединение подграфов в кластеры. Процесс расчета показателей можно распараллелить, подавая каждому процессу на вход пару подграфов. Сложность этого процесса оценивается как <math>m log(m)</math>. Соединение подграфов в кластеры выполняется последовательно, сложность процесса составляет <math>m^2 log(m)</math>

Таким образом получаем общую параллельную сложность алгоритма: <math>O(n+ n log(n) + m^2 log (m) + m log(m))</math>

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

1. Симметрическая матрица <math>A</math> расстояний между элементами данных размера <math>n\times n</math> с нулями на главной диагонали (<math>a_{ii}= 0, i = 1, \ldots, N</math>).

2. <math>k</math> - количество ближайших соседей для вершин (рекомендуемое значение <math>k</math> от 5 до 20 в зависимости от количества анализируемых объектов).

3. <math>l</math> - наименьшее число вершин, которое может содержать наибольший подкластер на 2-м этапе . Величина этого параметра варьируется от 1 до 5 % от общего числа объектов.

'''Объём входных данных'''

<math>\frac{n (n - 1)}{2}</math> (в силу симметричности и нулевой главной диагонали достаточно хранить только над/поддиагональные элементы).

'''Выходные данные'''

Вектор из <math>n</math> чисел <math>u_{1}, u_{2}, \ldots, u_{N}</math>, где <math>u_{i}</math> - целое число, соответствующее кластеру <math>i</math>-го объекта.

'''Объём выходных данных'''

<math>n</math>

== Свойства алгоритма ==
Соотношение последовательной и параллельной сложности на первом этапе является ''линейным'' для больших наборов данных и логарифмическим для n вершин. На втором этапе сложно оценить это соотношение - оно сильно зависит от параметров <math>k</math> и <math>l</math>. На третьем этапе соотношение равно <math>O(1)</math>

Алгоритм является недетерминированным. Хотя 1-й этап детерминирован, на 2-ом этапе могут быть найдены различные разбиения на подграфы, что повлияет и на итоговый результат работы алгоритма.

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

см. позднее

== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Последовательная реализация алгоритма доступна по ссылке [5].

CHAMELEON можно реализовать с использованием графовых библиотек METIS [6], hMETIS [7] и RANN [8].

Существует исследование, связанное с реализацией CHAMELEON посредством технологии OpenMP, с которым можно ознакомиться здесь [9].

Параллельных реализаций алгоритма CHAMELEON не найдено.

= Литература =
[1] George Karypis, Eui-Hong (Sam) Han и Vipin Kumar, «Chameleon: Hierarchical Clustering Using Dynamic Modeling», 1999.

[2] http://studopedia.ru/7_41934_algoritm-dinamicheskoy-ierarhicheskoy-klasterizatsii-CHAMELEON.html

[3] J.H. Friedman, J.L. Bentley, and R.A. Finkel. An algorithm for ﬁnding best matches in logarithmic expected time. ACM Transactions on Mathematical Software, 3:209–226, 1977.

[4] S. Berchtold, C. Bohm, D. Keim, and H.-P. Kriegel. Cost model for nearest neighbor search in high dimensional data space. In Proc. of Symposium on Principles of Database Systems, Tucson, Arizona, 1997.

[5] http://www.codeforge.com/article/192925

[6] http://glaros.dtc.umn.edu/gkhome/metis/metis/overview

[7] http://glaros.dtc.umn.edu/gkhome/metis/hmetis/overview

[8] https://cran.r-project.org/web/packages/RANN/index.html

[9] http://research.ijcaonline.org/volume79/number8/pxc3891600.pdf

Участник:ЕкатеринаКозырева/Алгоритм динамической иерархической кластеризации CHAMELEON

2016-10-31T18:25:19Z

ЕкатеринаКозырева: /* часть. Программная реализация алгоритма */

{{algorithm
| name = Алгоритм динамической иерархической кластеризации CHAMELEON
| serial_complexity = <math>O(nm + n log n + m^2 log m)</math>
| input_data = <math>\frac{n (n - 1)}{2}</math>
| output_data = <math>n</math>
| pf_height = <math>O(n+ n log(n) + m^2 log (m) + m log(m))</math>
| pf_width = <math>O(n)</math>
}}

Автор описания [[Участник:ЕкатеринаКозырева|Е.А.Козырева]]
= Свойства и структура алгоритмов =

== Общее описание алгоритма ==
Алгоритм CHAMELEON был предложен в 1999 году тремя учеными из университета Миннесоты – George Karypis, Eui-Hong (Sam) Han и Vipin Kumar<ref>George Karypis, Eui-Hong (Sam) Han и Vipin Kumar, «Chameleon: Hierarchical Clustering Using Dynamic Modeling», 1999.</ref>.

Предназначен для решения задач кластеризации. Кластеризация (или кластерный анализ) — это задача разбиения множества объектов на группы, называемые кластерами. Внутри каждой группы должны оказаться «похожие» объекты, а объекты разных группы должны быть как можно более отличны.

CHAMELEON - это агломеративный иерархический алгоритм кластеризации, ключевой особенностью которого является то, что он учитывает и взаимную связность, и сходство при определении наиболее похожей пары подкластеров, основываясь на динамической модели. Это означает, что в процессе кластеризации два кластера объединяются, только если их относительная взаимная связность и относительное взаимное сходство являются высокими по отношению к внутренней взаимосвязанности кластеров и близости элементов внутри кластеров. Кроме того, CHAMELEON использует подход для моделирования степени взаимосвязанности и близости между каждой парой кластеров, который учитывает внутренние характеристики самих кластеров. Таким образом, он может автоматически адаптироваться к внутренним характеристикам объединяемых кластеров.

CHAMELEON находит кластеры в наборе данных с помощью трехфазного алгоритма. На первой фазе происходит построение графа, путём добавления рёбер по принципу k ближайших соседей. На второй фазе CHAMELEON группирует полученные элементы в множество относительно небольших подграфов. Во время третьей фазы применяется агломеративный иерархический алгоритм кластеризации, с помощью которого находятся естесственные кластеры путем многократного объединения подграфов, полученных на прошлом этапе.

[[File:Chameleon.png]]

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

''Исходные данные'':

* Множество из n точек <math>V= {v_{ij}}</math> в метрическом пространстве, которое задано симметрической матрицей расстояний <math>A</math> размера <math>n\times n</math>.
* <math>k</math> - количество ближайших соседей для вершин, <math>k \in N, k \leq n</math>.
* <math>l</math> - наименьшее число вершин, которое может содержать наибольший подграф на 2-м этапе, <math>l \in N, l \leq n</math>.

''Обозначения'':

* <math>G = (V, E)</math> - граф, полученный путём соединения каждой точки с её <math>k</math> ближайшими соседями.

* <math>K= \{K_{i}\}</math> - разбиение множества <math>V</math> на набор попарно непересекающихся связных подмножеств, полученное в результате выполнения второй фазы алгоритма.

* <math>G_{2} = (K, E_{2})</math> - взвешенный граф, вершинами которого являются получившиеся подграфы, а ребрами - количество ребер исходного графа, соединяющих соответствующие подграфы.

* <math>C = \{C_{i}\}</math> - итоговое разбиение множества вершин графа <math>G_{2}</math> на набор кластеров.

''Вспомогательные понятия''

*<math>EC_{(C_{i},C_{j})}</math> - абсолютная взаимная связность пары кластеров <math>C_{i}, C{j}</math>. Определяется как сумма весов ребер, соединяющих вершины, принадлежащие <math>C{i}</math> c вершинами из <math>C{j}</math>. Внутренняя связность <math>EC_{(C_{i},C_{i})}</math> вычисляется как сумма ребер, входящих в разделитель, разбивающий <math>C{i}</math> на два равных подграфа.

*<math>RI_{(C_{i},C_{j})} = \frac{|EC_{(C_{i},C_{j})}|}{(|EC_{C_{i}}|+|EC_{C_{j}}|)/2}</math> - относительная взаимная связность пары кластеров <math>C_{i}, C{j}</math>

*<math>S_{EC_{(C_{i},C_{j})}}</math> - абсолютное взаимное сходство пары кластеров <math>C_{i}, C{j}</math>. Подсчитывается как среднее сходство между соединенными вершинами, принадлежащими <math>C{i}</math> и <math>C{j}</math> соответственно. Соединения обусловлены разбиением общего графа, полученного на первом этапе алгоритма.

*<math> RC_{(C_{i},C_{j})}= \frac{S_{EC_{(C_{i},C_{j})}}}{\frac{|C_{i}|}{|C_{i}+C_{j}|}*S_{EC_{(C_{i})}}+\frac{|C_{i}|}{|C_{i}+C_{j}|}*S_{EC_{(C_{j})}}}</math> - относительное взаимное сходство пары кластеров <math>C_{i}, C{j}</math>. Определяется как абсолютное сходство между этой парой кластеров, нормализованное с учетом их внутреннего сходства.

'''Первый этап'''

На первом этапе, согласно графо-ориентированному подходу, происходит построение графа <math>G = (V, E)</math> на матрице сходства объектов по принципу k ближайших соседей. Две вершины такого графа соединяет ребро, если объект, соответствующий любой из этих вершин попадает в число k наиболее близких объектов для объекта, соответствующего другой вершине из данной пары.
[[Файл:Снимок chameleon.PNG]]

'''Второй этап'''

Алгоритм разделяет полученный граф на множество сравнительно малых подграфов <math>K= \{K_{i}\}</math>. Разделение происходит последовательно. На каждом шаге выбирается подграф, содержащий наибольшее число вершин. Этот граф разделяется на два подграфа так, что разделитель ребер графа минимален и каждый из получаемых подграфов содержит не менее 25 % вершин исходного графа. Процесс разделения останавливается, когда наибольший подграф содержит меньше некоторого заданного числа вершин. Обычно величина этого параметра задается равной значению от 1 до 5 % от числа объектов. Полученное множество связных графов считается множеством начальных кластеров, на котором требуется провести последовательное иерархическое объединение.

'''Третий этап'''

Третий этап заключается в итеративном преобразовании множества подграфов <math>K= \{K_{i}\}</math> в множество кластеров <math>C = \{C_{i}\}</math>. Алгоритм осуществляет агломеративную иерархическую кластеризацию на основании показателей <math>EC_{(C_{i},C_{j})}</math>, <math>S_{EC_{(C_{i},C_{j})}}</math>, <math>RI_{(C_{i},C_{j})} </math>, <math> RC_{(C_{i},C_{j})}</math>. Существует две стратегии анализа показателей сходства. Первая подразумевает наличие некоторых пороговых значений <math>T_{RI}</math> и <math>T_{RC}</math>. В соответствии с этой стратегией, алгоритм для каждого кластера <math>C_{i}</math> проверяет, отвечают ли смежные (наиболее близкие) ему кластеры условиям:

*<math>RI_{(C_{i},C_{j})} \geqslant T_{RI}</math>

*<math>RC_{(C_{i},C_{j})} \geqslant T_{RC}</math>

Если более одного смежного кластера отвечает этим условиям, то алгоритм выбирает для объединения наиболее связный кластер (граф), то есть такой кластер <math>C_{j}</math>, с которым у кластера <math>C_{i}</math> получается наибольшая абсолютная взаимная связность. По завершению прохода по всем кластерам, созданные таким образом пары объединяются. Параметры <math>T_{RI}</math> и <math>T_{RC}</math> могут использоваться для изменения характеристик получаемых кластеров.

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

<math>RI_{(C_{i},C_{j})}*RC_{(C_{i},C_{j})}^\alpha</math>,

где <math>\alpha</math> выбирается пользователем. Если <math>\alpha > 1 </math>, то алгоритм придает большее значение относительному взаимному сходству, а если <math>\alpha < 1 </math>, то большее значение имеет относительная взаимная связность.

''Вычисляемые данные'':

<math>U = (u_1, u_2, ..., u_n)</math> - n-мерный вектор, где <math>u_i \in N_{[C]}</math> - порядковый номер кластера, к которому принадлежит вершина i исходного множества V.

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

Алгоритм имеет три вычислительных ядра, по одному на каждый этап.

На первом этапе вычислительным ядром является процесс нахождения <math>k</math> ближайших соседей для каждой вершины, который заключается в анализе матрицы расстояний.

На втором этапе вычислительным ядром является процесс поиска подходящего разбиения очередного подграфа на два графа с минимизацией разделителя ребер графа.

На третьем этапе вычислительным ядром является расчет величин <math>EC_{(C_{i},C_{j})}</math>, <math>S_{EC_{(C_{i},C_{j})}}</math>, <math>RI_{(C_{i},C_{j})} </math>, <math> RC_{(C_{i},C_{j})}</math> для каждой пары смежных кластеров.

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

Как уже рассказывалось ранее, алгоритм включает в себя три основных этапа, каждый из которых, по сути, является отдельным алгоритмом. Этапы выполняются последовательно относительно друг друга.

Макрооперация на первом этапе - процедура нахождения <math>k</math> ближайших соседей, на втором - процедура разбиения наибольшего подграфа на два графа, на третьем - процедура вычисления показателей сходства, на основе которых принимается решение о слиянии подграфов в кластер.

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

'''Первый этап'''
int n; //количество вершин
int k; //количество соседей
int A[n][n] //матрица расстояний
int D[k] //массив вершин-соседей
int E[n][n] //матрица ребер графа <math>G_{2} = (K, E_{2})</math>
for i=1 to n-1 do
{
for j=i+1 to n do
{
//заполняем массив вершин-соседей вставляя новые вершины, если они ближе, чем самая далекая из массива.
}
for j=0 to k do
{
//для каждой вершины соседа заполняем соответствующую ячейку из матрицы E[n][n] единицей
}

}

'''Второй этап'''

1. Все связные подграфы в отсортированном порядке помещаются в список;
2. Берем наибольший элемент списка, вычисляем количество его вершин. Если число вершин > l, то идем в пункт 3. Иначе в пункт 5;
3. Разбиваем подграф на два подграфа таким образом, чтобы разделитель ребер графа был минимален и каждый из получаемых подграфов содержал не менее 25 % вершин исходного графа;
4. Добавляем полученные элементы в список подграфов таким образом, чтобы список оставался отсортированным. Идем в пункт 2;
5. Нашли искомое множество подграфов math>K = \{K_{i}\}</math>;
6. Создаем и заполняем матрицу матрицу расстояний для графа <math>G_{2} = (K, E_{2})</math>. Получаем искомый набор рёбер <math>E_{2}</math>.

'''Третий этап'''

1. Заводим два массива: а) массив кластеров C, полученных на предыдущем этапе, б) массив объединений кластеров F, которые мы будем получать на этом этапе;
2. Берем следующий кластер <math>C_{i}</math> (на первом шаге - первый). Если все кластеры просмотрены, идем в пункт 6;
3. Берем следующий кластер <math>C_{j}, i<>j</math>. Если все кластеры просмотрены, то идем в пункт 2;
4. Проверяем смежность <math>C_{i}</math> и <math>C_{j}</math>. Если не смежны, то возвращаемся в пункт 3. Если смежны, идем в пункт 5;
5. Рассчитываем показатели <math>RI_{(C_{i},C_{j})}</math> и <math> RC_{(C_{i},C_{j})}</math>. Проверяем, удовлетворяют ли найденные значения условиям:
*<math>RI_{(C_{i},C_{j})} \geqslant T_{RI}</math>
*<math>RC_{(C_{i},C_{j})} \geqslant T_{RC}</math>
Если нет, то идем в пункт 3. Иначе если смежность пары кластеров выше, чем у предыдущих найденных, то <math>F_{i}=j</math>. Идем в пункт 3;
6. Если в списке F есть хотя бы одна пара кластеров для слияния, то выполняем слияние, обновляем массив кластеров и массив объединений кластеров. Идем в пункт 2.

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

1) Для построения графа на основе метода k ближайших соседей для n вершин требуется <math>O(n log(n))</math> операций [3]; для наборов данных большой размерности эта величина составляет <math>O(n^2)</math> операций [4];

2) Для выделения множества сравнительно малых связных подграфов требуется <math>nm</math> операций, где <math>m</math> - количество подграфов, полученных на втором этапе алгоритма;

3) Формирование набора кластеров, на основе множества подграфов, полученных на предыдущем этапе, требует <math>m^2log(m)</math> операций.

Итого, для n вершин получаем последовательную сложность <math>O(n log(n)+nm+m^2log(m))</math>.

== Информационный граф ==
[[File:СК.png]]

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

Первый этап работы алгоритма можно распределить между <math>n</math> процессами. На вход каждому процессу подается своя вершина, далее происходит процедура поиска <math>k</math> ближайших соседей. Параллельная сложность составляет <math>O(n)</math>.

Второй и третий этапы можно распараллелить частично.

Второй этап распараллеливается путем подачи на вход свободному процессу очередного подграфа для разделения. Число итераций оценивается в <math>O(n log(n))</math>.

Третий этап делится на расчет показателей схожести и соединение подграфов в кластеры. Процесс расчета показателей можно распараллелить, подавая каждому процессу на вход пару подграфов. Сложность этого процесса оценивается как <math>m log(m)</math>. Соединение подграфов в кластеры выполняется последовательно, сложность процесса составляет <math>m^2 log(m)</math>

Таким образом получаем общую параллельную сложность алгоритма: <math>O(n+ n log(n) + m^2 log (m) + m log(m))</math>

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

1. Симметрическая матрица <math>A</math> расстояний между элементами данных размера <math>n\times n</math> с нулями на главной диагонали (<math>a_{ii}= 0, i = 1, \ldots, N</math>).

2. <math>k</math> - количество ближайших соседей для вершин (рекомендуемое значение <math>k</math> от 5 до 20 в зависимости от количества анализируемых объектов).

3. <math>l</math> - наименьшее число вершин, которое может содержать наибольший подкластер на 2-м этапе . Величина этого параметра варьируется от 1 до 5 % от общего числа объектов.

'''Объём входных данных'''

<math>\frac{n (n - 1)}{2}</math> (в силу симметричности и нулевой главной диагонали достаточно хранить только над/поддиагональные элементы).

'''Выходные данные'''

Вектор из <math>n</math> чисел <math>u_{1}, u_{2}, \ldots, u_{N}</math>, где <math>u_{i}</math> - целое число, соответствующее кластеру <math>i</math>-го объекта.

'''Объём выходных данных'''

<math>n</math>

== Свойства алгоритма ==
Соотношение последовательной и параллельной сложности на первом этапе является ''линейным'' для больших наборов данных и логарифмическим для n вершин. На втором этапе сложно оценить это соотношение - оно сильно зависит от параметров <math>k</math> и <math>l</math>. На третьем этапе соотношение равно <math>O(1)</math>

Алгоритм является недетерминированным. Хотя 1-й этап детерминирован, на 2-ом этапе могут быть найдены различные разбиения на подграфы, что повлияет и на итоговый результат работы алгоритма.

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

см. позднее

== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Последовательная реализация алгоритма доступна по ссылке [5].

CHAMELEON можно реализовать с использованием графовых библиотек METIS [6], hMETIS [7] и RANN [8].

Существует исследование, связанное с реализацией CHAMELEON посредством технологии OpenMP, с которым можно ознакомиться здесь [9].

Параллельных реализаций алгоритма CHAMELEON не найдено.

= Литература =
[1] George Karypis, Eui-Hong (Sam) Han и Vipin Kumar, «Chameleon: Hierarchical Clustering Using Dynamic Modeling», 1999.

[2] http://studopedia.ru/7_41934_algoritm-dinamicheskoy-ierarhicheskoy-klasterizatsii-CHAMELEON.html

[3] J.H. Friedman, J.L. Bentley, and R.A. Finkel. An algorithm for ﬁnding best matches in logarithmic expected time. ACM Transactions on Mathematical Software, 3:209–226, 1977.

[4] S. Berchtold, C. Bohm, D. Keim, and H.-P. Kriegel. Cost model for nearest neighbor search in high dimensional data space. In Proc. of Symposium on Principles of Database Systems, Tucson, Arizona, 1997.

[5] http://www.codeforge.com/article/192925

[6] http://glaros.dtc.umn.edu/gkhome/metis/metis/overview

[7] http://glaros.dtc.umn.edu/gkhome/metis/hmetis/overview

[8] https://cran.r-project.org/web/packages/RANN/index.html

[9] http://research.ijcaonline.org/volume79/number8/pxc3891600.pdf

Участник:ЕкатеринаКозырева/Алгоритм динамической иерархической кластеризации CHAMELEON

2016-10-31T18:23:47Z

ЕкатеринаКозырева: /* */

{{algorithm
| name = Алгоритм динамической иерархической кластеризации CHAMELEON
| serial_complexity = <math>O(nm + n log n + m^2 log m)</math>
| input_data = <math>\frac{n (n - 1)}{2}</math>
| output_data = <math>n</math>
| pf_height = <math>O(n+ n log(n) + m^2 log (m) + m log(m))</math>
| pf_width = <math>O(n)</math>
}}

Автор описания [[Участник:ЕкатеринаКозырева|Е.А.Козырева]]
= Свойства и структура алгоритмов =

== Общее описание алгоритма ==
Алгоритм CHAMELEON был предложен в 1999 году тремя учеными из университета Миннесоты – George Karypis, Eui-Hong (Sam) Han и Vipin Kumar<ref>George Karypis, Eui-Hong (Sam) Han и Vipin Kumar, «Chameleon: Hierarchical Clustering Using Dynamic Modeling», 1999.</ref>.

Предназначен для решения задач кластеризации. Кластеризация (или кластерный анализ) — это задача разбиения множества объектов на группы, называемые кластерами. Внутри каждой группы должны оказаться «похожие» объекты, а объекты разных группы должны быть как можно более отличны.

CHAMELEON - это агломеративный иерархический алгоритм кластеризации, ключевой особенностью которого является то, что он учитывает и взаимную связность, и сходство при определении наиболее похожей пары подкластеров, основываясь на динамической модели. Это означает, что в процессе кластеризации два кластера объединяются, только если их относительная взаимная связность и относительное взаимное сходство являются высокими по отношению к внутренней взаимосвязанности кластеров и близости элементов внутри кластеров. Кроме того, CHAMELEON использует подход для моделирования степени взаимосвязанности и близости между каждой парой кластеров, который учитывает внутренние характеристики самих кластеров. Таким образом, он может автоматически адаптироваться к внутренним характеристикам объединяемых кластеров.

CHAMELEON находит кластеры в наборе данных с помощью трехфазного алгоритма. На первой фазе происходит построение графа, путём добавления рёбер по принципу k ближайших соседей. На второй фазе CHAMELEON группирует полученные элементы в множество относительно небольших подграфов. Во время третьей фазы применяется агломеративный иерархический алгоритм кластеризации, с помощью которого находятся естесственные кластеры путем многократного объединения подграфов, полученных на прошлом этапе.

[[File:Chameleon.png]]

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

''Исходные данные'':

* Множество из n точек <math>V= {v_{ij}}</math> в метрическом пространстве, которое задано симметрической матрицей расстояний <math>A</math> размера <math>n\times n</math>.
* <math>k</math> - количество ближайших соседей для вершин, <math>k \in N, k \leq n</math>.
* <math>l</math> - наименьшее число вершин, которое может содержать наибольший подграф на 2-м этапе, <math>l \in N, l \leq n</math>.

''Обозначения'':

* <math>G = (V, E)</math> - граф, полученный путём соединения каждой точки с её <math>k</math> ближайшими соседями.

* <math>K= \{K_{i}\}</math> - разбиение множества <math>V</math> на набор попарно непересекающихся связных подмножеств, полученное в результате выполнения второй фазы алгоритма.

* <math>G_{2} = (K, E_{2})</math> - взвешенный граф, вершинами которого являются получившиеся подграфы, а ребрами - количество ребер исходного графа, соединяющих соответствующие подграфы.

* <math>C = \{C_{i}\}</math> - итоговое разбиение множества вершин графа <math>G_{2}</math> на набор кластеров.

''Вспомогательные понятия''

*<math>EC_{(C_{i},C_{j})}</math> - абсолютная взаимная связность пары кластеров <math>C_{i}, C{j}</math>. Определяется как сумма весов ребер, соединяющих вершины, принадлежащие <math>C{i}</math> c вершинами из <math>C{j}</math>. Внутренняя связность <math>EC_{(C_{i},C_{i})}</math> вычисляется как сумма ребер, входящих в разделитель, разбивающий <math>C{i}</math> на два равных подграфа.

*<math>RI_{(C_{i},C_{j})} = \frac{|EC_{(C_{i},C_{j})}|}{(|EC_{C_{i}}|+|EC_{C_{j}}|)/2}</math> - относительная взаимная связность пары кластеров <math>C_{i}, C{j}</math>

*<math>S_{EC_{(C_{i},C_{j})}}</math> - абсолютное взаимное сходство пары кластеров <math>C_{i}, C{j}</math>. Подсчитывается как среднее сходство между соединенными вершинами, принадлежащими <math>C{i}</math> и <math>C{j}</math> соответственно. Соединения обусловлены разбиением общего графа, полученного на первом этапе алгоритма.

*<math> RC_{(C_{i},C_{j})}= \frac{S_{EC_{(C_{i},C_{j})}}}{\frac{|C_{i}|}{|C_{i}+C_{j}|}*S_{EC_{(C_{i})}}+\frac{|C_{i}|}{|C_{i}+C_{j}|}*S_{EC_{(C_{j})}}}</math> - относительное взаимное сходство пары кластеров <math>C_{i}, C{j}</math>. Определяется как абсолютное сходство между этой парой кластеров, нормализованное с учетом их внутреннего сходства.

'''Первый этап'''

На первом этапе, согласно графо-ориентированному подходу, происходит построение графа <math>G = (V, E)</math> на матрице сходства объектов по принципу k ближайших соседей. Две вершины такого графа соединяет ребро, если объект, соответствующий любой из этих вершин попадает в число k наиболее близких объектов для объекта, соответствующего другой вершине из данной пары.
[[Файл:Снимок chameleon.PNG]]

'''Второй этап'''

Алгоритм разделяет полученный граф на множество сравнительно малых подграфов <math>K= \{K_{i}\}</math>. Разделение происходит последовательно. На каждом шаге выбирается подграф, содержащий наибольшее число вершин. Этот граф разделяется на два подграфа так, что разделитель ребер графа минимален и каждый из получаемых подграфов содержит не менее 25 % вершин исходного графа. Процесс разделения останавливается, когда наибольший подграф содержит меньше некоторого заданного числа вершин. Обычно величина этого параметра задается равной значению от 1 до 5 % от числа объектов. Полученное множество связных графов считается множеством начальных кластеров, на котором требуется провести последовательное иерархическое объединение.

'''Третий этап'''

Третий этап заключается в итеративном преобразовании множества подграфов <math>K= \{K_{i}\}</math> в множество кластеров <math>C = \{C_{i}\}</math>. Алгоритм осуществляет агломеративную иерархическую кластеризацию на основании показателей <math>EC_{(C_{i},C_{j})}</math>, <math>S_{EC_{(C_{i},C_{j})}}</math>, <math>RI_{(C_{i},C_{j})} </math>, <math> RC_{(C_{i},C_{j})}</math>. Существует две стратегии анализа показателей сходства. Первая подразумевает наличие некоторых пороговых значений <math>T_{RI}</math> и <math>T_{RC}</math>. В соответствии с этой стратегией, алгоритм для каждого кластера <math>C_{i}</math> проверяет, отвечают ли смежные (наиболее близкие) ему кластеры условиям:

*<math>RI_{(C_{i},C_{j})} \geqslant T_{RI}</math>

*<math>RC_{(C_{i},C_{j})} \geqslant T_{RC}</math>

Если более одного смежного кластера отвечает этим условиям, то алгоритм выбирает для объединения наиболее связный кластер (граф), то есть такой кластер <math>C_{j}</math>, с которым у кластера <math>C_{i}</math> получается наибольшая абсолютная взаимная связность. По завершению прохода по всем кластерам, созданные таким образом пары объединяются. Параметры <math>T_{RI}</math> и <math>T_{RC}</math> могут использоваться для изменения характеристик получаемых кластеров.

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

<math>RI_{(C_{i},C_{j})}*RC_{(C_{i},C_{j})}^\alpha</math>,

где <math>\alpha</math> выбирается пользователем. Если <math>\alpha > 1 </math>, то алгоритм придает большее значение относительному взаимному сходству, а если <math>\alpha < 1 </math>, то большее значение имеет относительная взаимная связность.

''Вычисляемые данные'':

<math>U = (u_1, u_2, ..., u_n)</math> - n-мерный вектор, где <math>u_i \in N_{[C]}</math> - порядковый номер кластера, к которому принадлежит вершина i исходного множества V.

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

Алгоритм имеет три вычислительных ядра, по одному на каждый этап.

На первом этапе вычислительным ядром является процесс нахождения <math>k</math> ближайших соседей для каждой вершины, который заключается в анализе матрицы расстояний.

На втором этапе вычислительным ядром является процесс поиска подходящего разбиения очередного подграфа на два графа с минимизацией разделителя ребер графа.

На третьем этапе вычислительным ядром является расчет величин <math>EC_{(C_{i},C_{j})}</math>, <math>S_{EC_{(C_{i},C_{j})}}</math>, <math>RI_{(C_{i},C_{j})} </math>, <math> RC_{(C_{i},C_{j})}</math> для каждой пары смежных кластеров.

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

Как уже рассказывалось ранее, алгоритм включает в себя три основных этапа, каждый из которых, по сути, является отдельным алгоритмом. Этапы выполняются последовательно относительно друг друга.

Макрооперация на первом этапе - процедура нахождения <math>k</math> ближайших соседей, на втором - процедура разбиения наибольшего подграфа на два графа, на третьем - процедура вычисления показателей сходства, на основе которых принимается решение о слиянии подграфов в кластер.

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

'''Первый этап'''
int n; //количество вершин
int k; //количество соседей
int A[n][n] //матрица расстояний
int D[k] //массив вершин-соседей
int E[n][n] //матрица ребер графа <math>G_{2} = (K, E_{2})</math>
for i=1 to n-1 do
{
for j=i+1 to n do
{
//заполняем массив вершин-соседей вставляя новые вершины, если они ближе, чем самая далекая из массива.
}
for j=0 to k do
{
//для каждой вершины соседа заполняем соответствующую ячейку из матрицы E[n][n] единицей
}

}

'''Второй этап'''

1. Все связные подграфы в отсортированном порядке помещаются в список;
2. Берем наибольший элемент списка, вычисляем количество его вершин. Если число вершин > l, то идем в пункт 3. Иначе в пункт 5;
3. Разбиваем подграф на два подграфа таким образом, чтобы разделитель ребер графа был минимален и каждый из получаемых подграфов содержал не менее 25 % вершин исходного графа;
4. Добавляем полученные элементы в список подграфов таким образом, чтобы список оставался отсортированным. Идем в пункт 2;
5. Нашли искомое множество подграфов math>K = \{K_{i}\}</math>;
6. Создаем и заполняем матрицу матрицу расстояний для графа <math>G_{2} = (K, E_{2})</math>. Получаем искомый набор рёбер <math>E_{2}</math>.

'''Третий этап'''

1. Заводим два массива: а) массив кластеров C, полученных на предыдущем этапе, б) массив объединений кластеров F, которые мы будем получать на этом этапе;
2. Берем следующий кластер <math>C_{i}</math> (на первом шаге - первый). Если все кластеры просмотрены, идем в пункт 6;
3. Берем следующий кластер <math>C_{j}, i<>j</math>. Если все кластеры просмотрены, то идем в пункт 2;
4. Проверяем смежность <math>C_{i}</math> и <math>C_{j}</math>. Если не смежны, то возвращаемся в пункт 3. Если смежны, идем в пункт 5;
5. Рассчитываем показатели <math>RI_{(C_{i},C_{j})}</math> и <math> RC_{(C_{i},C_{j})}</math>. Проверяем, удовлетворяют ли найденные значения условиям:
*<math>RI_{(C_{i},C_{j})} \geqslant T_{RI}</math>
*<math>RC_{(C_{i},C_{j})} \geqslant T_{RC}</math>
Если нет, то идем в пункт 3. Иначе если смежность пары кластеров выше, чем у предыдущих найденных, то <math>F_{i}=j</math>. Идем в пункт 3;
6. Если в списке F есть хотя бы одна пара кластеров для слияния, то выполняем слияние, обновляем массив кластеров и массив объединений кластеров. Идем в пункт 2.

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

1) Для построения графа на основе метода k ближайших соседей для n вершин требуется <math>O(n log(n))</math> операций [3]; для наборов данных большой размерности эта величина составляет <math>O(n^2)</math> операций [4];

2) Для выделения множества сравнительно малых связных подграфов требуется <math>nm</math> операций, где <math>m</math> - количество подграфов, полученных на втором этапе алгоритма;

3) Формирование набора кластеров, на основе множества подграфов, полученных на предыдущем этапе, требует <math>m^2log(m)</math> операций.

Итого, для n вершин получаем последовательную сложность <math>O(n log(n)+nm+m^2log(m))</math>.

== Информационный граф ==
[[File:СК.png]]

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

Первый этап работы алгоритма можно распределить между <math>n</math> процессами. На вход каждому процессу подается своя вершина, далее происходит процедура поиска <math>k</math> ближайших соседей. Параллельная сложность составляет <math>O(n)</math>.

Второй и третий этапы можно распараллелить частично.

Второй этап распараллеливается путем подачи на вход свободному процессу очередного подграфа для разделения. Число итераций оценивается в <math>O(n log(n))</math>.

Третий этап делится на расчет показателей схожести и соединение подграфов в кластеры. Процесс расчета показателей можно распараллелить, подавая каждому процессу на вход пару подграфов. Сложность этого процесса оценивается как <math>m log(m)</math>. Соединение подграфов в кластеры выполняется последовательно, сложность процесса составляет <math>m^2 log(m)</math>

Таким образом получаем общую параллельную сложность алгоритма: <math>O(n+ n log(n) + m^2 log (m) + m log(m))</math>

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

1. Симметрическая матрица <math>A</math> расстояний между элементами данных размера <math>n\times n</math> с нулями на главной диагонали (<math>a_{ii}= 0, i = 1, \ldots, N</math>).

2. <math>k</math> - количество ближайших соседей для вершин (рекомендуемое значение <math>k</math> от 5 до 20 в зависимости от количества анализируемых объектов).

3. <math>l</math> - наименьшее число вершин, которое может содержать наибольший подкластер на 2-м этапе . Величина этого параметра варьируется от 1 до 5 % от общего числа объектов.

'''Объём входных данных'''

<math>\frac{n (n - 1)}{2}</math> (в силу симметричности и нулевой главной диагонали достаточно хранить только над/поддиагональные элементы).

'''Выходные данные'''

Вектор из <math>n</math> чисел <math>u_{1}, u_{2}, \ldots, u_{N}</math>, где <math>u_{i}</math> - целое число, соответствующее кластеру <math>i</math>-го объекта.

'''Объём выходных данных'''

<math>n</math>

== Свойства алгоритма ==
Соотношение последовательной и параллельной сложности на первом этапе является ''линейным'' для больших наборов данных и логарифмическим для n вершин. На втором этапе сложно оценить это соотношение - оно сильно зависит от параметров <math>k</math> и <math>l</math>. На третьем этапе соотношение равно <math>O(1)</math>

Алгоритм является недетерминированным. Хотя 1-й этап детерминирован, на 2-ом этапе могут быть найдены различные разбиения на подграфы, что повлияет и на итоговый результат работы алгоритма.

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

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

см. позднее

== ==
== ==
== Существующие реализации алгоритма ==
Последовательная реализация алгоритма доступна по ссылке [5].

CHAMELEON можно реализовать с использованием графовых библиотек METIS [6], hMETIS [7] и RANN [8].

Существует исследование, связанное с реализацией CHAMELEON посредством технологии OpenMP, с которым можно ознакомиться здесь [9].

Параллельных реализаций алгоритма CHAMELEON не найдено.

= Литература =
[1] George Karypis, Eui-Hong (Sam) Han и Vipin Kumar, «Chameleon: Hierarchical Clustering Using Dynamic Modeling», 1999.

[2] http://studopedia.ru/7_41934_algoritm-dinamicheskoy-ierarhicheskoy-klasterizatsii-CHAMELEON.html

[3] J.H. Friedman, J.L. Bentley, and R.A. Finkel. An algorithm for ﬁnding best matches in logarithmic expected time. ACM Transactions on Mathematical Software, 3:209–226, 1977.

[4] S. Berchtold, C. Bohm, D. Keim, and H.-P. Kriegel. Cost model for nearest neighbor search in high dimensional data space. In Proc. of Symposium on Principles of Database Systems, Tucson, Arizona, 1997.

[5] http://www.codeforge.com/article/192925

[6] http://glaros.dtc.umn.edu/gkhome/metis/metis/overview

[7] http://glaros.dtc.umn.edu/gkhome/metis/hmetis/overview

[8] https://cran.r-project.org/web/packages/RANN/index.html

[9] http://research.ijcaonline.org/volume79/number8/pxc3891600.pdf

Участник:ЕкатеринаКозырева/Алгоритм динамической иерархической кластеризации CHAMELEON

2016-10-30T20:53:41Z

ЕкатеринаКозырева: /* Общее описание алгоритма */

{{algorithm
| name = Алгоритм динамической иерархической кластеризации CHAMELEON
| serial_complexity = <math>O(nm + n log n + m^2 log m)</math>
| input_data = <math>\frac{n (n - 1)}{2}</math>
| output_data = <math>n</math>
| pf_height = <math>O(n+ n log(n) + m^2 log (m) + m log(m))</math>
| pf_width = <math>O(n)</math>
}}

Автор описания [[Участник:ЕкатеринаКозырева|Е.А.Козырева]]
= Свойства и структура алгоритмов =

== Общее описание алгоритма ==
Алгоритм CHAMELEON был предложен в 1999 году тремя учеными из университета Миннесоты – George Karypis, Eui-Hong (Sam) Han и Vipin Kumar<ref>George Karypis, Eui-Hong (Sam) Han и Vipin Kumar, «Chameleon: Hierarchical Clustering Using Dynamic Modeling», 1999.</ref>.

Предназначен для решения задач кластеризации. Кластеризация (или кластерный анализ) — это задача разбиения множества объектов на группы, называемые кластерами. Внутри каждой группы должны оказаться «похожие» объекты, а объекты разных группы должны быть как можно более отличны.

CHAMELEON - это агломеративный иерархический алгоритм кластеризации, ключевой особенностью которого является то, что он учитывает и взаимную связность, и сходство при определении наиболее похожей пары подкластеров, основываясь на динамической модели. Это означает, что в процессе кластеризации два кластера объединяются, только если их относительная взаимная связность и относительное взаимное сходство являются высокими по отношению к внутренней взаимосвязанности кластеров и близости элементов внутри кластеров. Кроме того, CHAMELEON использует подход для моделирования степени взаимосвязанности и близости между каждой парой кластеров, который учитывает внутренние характеристики самих кластеров. Таким образом, он может автоматически адаптироваться к внутренним характеристикам объединяемых кластеров.

CHAMELEON находит кластеры в наборе данных с помощью трехфазного алгоритма. На первой фазе происходит построение графа, путём добавления рёбер по принципу k ближайших соседей. На второй фазе CHAMELEON группирует полученные элементы в множество относительно небольших подграфов. Во время третьей фазы применяется агломеративный иерархический алгоритм кластеризации, с помощью которого находятся естесственные кластеры путем многократного объединения подграфов, полученных на прошлом этапе.

[[File:Chameleon.png]]

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

''Исходные данные'':

* Множество из n точек <math>V= {v_{ij}}</math> в метрическом пространстве, которое задано симметрической матрицей расстояний <math>A</math> размера <math>n\times n</math>.
* <math>k</math> - количество ближайших соседей для вершин, <math>k \in N, k \leq n</math>.
* <math>l</math> - наименьшее число вершин, которое может содержать наибольший подграф на 2-м этапе, <math>l \in N, l \leq n</math>.

''Обозначения'':

* <math>G = (V, E)</math> - граф, полученный путём соединения каждой точки с её <math>k</math> ближайшими соседями.

* <math>K= \{K_{i}\}</math> - разбиение множества <math>V</math> на набор попарно непересекающихся связных подмножеств, полученное в результате выполнения второй фазы алгоритма.

* <math>G_{2} = (K, E_{2})</math> - взвешенный граф, вершинами которого являются получившиеся подграфы, а ребрами - количество ребер исходного графа, соединяющих соответствующие подграфы.

* <math>C = \{C_{i}\}</math> - итоговое разбиение множества вершин графа <math>G_{2}</math> на набор кластеров.

''Вспомогательные понятия''

*<math>EC_{(C_{i},C_{j})}</math> - абсолютная взаимная связность пары кластеров <math>C_{i}, C{j}</math>. Определяется как сумма весов ребер, соединяющих вершины, принадлежащие <math>C{i}</math> c вершинами из <math>C{j}</math>. Внутренняя связность <math>EC_{(C_{i},C_{i})}</math> вычисляется как сумма ребер, входящих в разделитель, разбивающий <math>C{i}</math> на два равных подграфа.

*<math>RI_{(C_{i},C_{j})} = \frac{|EC_{(C_{i},C_{j})}|}{(|EC_{C_{i}}|+|EC_{C_{j}}|)/2}</math> - относительная взаимная связность пары кластеров <math>C_{i}, C{j}</math>

*<math>S_{EC_{(C_{i},C_{j})}}</math> - абсолютное взаимное сходство пары кластеров <math>C_{i}, C{j}</math>. Подсчитывается как среднее сходство между соединенными вершинами, принадлежащими <math>C{i}</math> и <math>C{j}</math> соответственно. Соединения обусловлены разбиением общего графа, полученного на первом этапе алгоритма.

*<math> RC_{(C_{i},C_{j})}= \frac{S_{EC_{(C_{i},C_{j})}}}{\frac{|C_{i}|}{|C_{i}+C_{j}|}*S_{EC_{(C_{i})}}+\frac{|C_{i}|}{|C_{i}+C_{j}|}*S_{EC_{(C_{j})}}}</math> - относительное взаимное сходство пары кластеров <math>C_{i}, C{j}</math>. Определяется как абсолютное сходство между этой парой кластеров, нормализованное с учетом их внутреннего сходства.

'''Первый этап'''

На первом этапе, согласно графо-ориентированному подходу, происходит построение графа <math>G = (V, E)</math> на матрице сходства объектов по принципу k ближайших соседей. Две вершины такого графа соединяет ребро, если объект, соответствующий любой из этих вершин попадает в число k наиболее близких объектов для объекта, соответствующего другой вершине из данной пары.
[[Файл:Снимок chameleon.PNG]]

'''Второй этап'''

Алгоритм разделяет полученный граф на множество сравнительно малых подграфов <math>K= \{K_{i}\}</math>. Разделение происходит последовательно. На каждом шаге выбирается подграф, содержащий наибольшее число вершин. Этот граф разделяется на два подграфа так, что разделитель ребер графа минимален и каждый из получаемых подграфов содержит не менее 25 % вершин исходного графа. Процесс разделения останавливается, когда наибольший подграф содержит меньше некоторого заданного числа вершин. Обычно величина этого параметра задается равной значению от 1 до 5 % от числа объектов. Полученное множество связных графов считается множеством начальных кластеров, на котором требуется провести последовательное иерархическое объединение.

'''Третий этап'''

Третий этап заключается в итеративном преобразовании множества подграфов <math>K= \{K_{i}\}</math> в множество кластеров <math>C = \{C_{i}\}</math>. Алгоритм осуществляет агломеративную иерархическую кластеризацию на основании показателей <math>EC_{(C_{i},C_{j})}</math>, <math>S_{EC_{(C_{i},C_{j})}}</math>, <math>RI_{(C_{i},C_{j})} </math>, <math> RC_{(C_{i},C_{j})}</math>. Существует две стратегии анализа показателей сходства. Первая подразумевает наличие некоторых пороговых значений <math>T_{RI}</math> и <math>T_{RC}</math>. В соответствии с этой стратегией, алгоритм для каждого кластера <math>C_{i}</math> проверяет, отвечают ли смежные (наиболее близкие) ему кластеры условиям:

*<math>RI_{(C_{i},C_{j})} \geqslant T_{RI}</math>

*<math>RC_{(C_{i},C_{j})} \geqslant T_{RC}</math>

Если более одного смежного кластера отвечает этим условиям, то алгоритм выбирает для объединения наиболее связный кластер (граф), то есть такой кластер <math>C_{j}</math>, с которым у кластера <math>C_{i}</math> получается наибольшая абсолютная взаимная связность. По завершению прохода по всем кластерам, созданные таким образом пары объединяются. Параметры <math>T_{RI}</math> и <math>T_{RC}</math> могут использоваться для изменения характеристик получаемых кластеров.

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

<math>RI_{(C_{i},C_{j})}*RC_{(C_{i},C_{j})}^\alpha</math>,

где <math>\alpha</math> выбирается пользователем. Если <math>\alpha > 1 </math>, то алгоритм придает большее значение относительному взаимному сходству, а если <math>\alpha < 1 </math>, то большее значение имеет относительная взаимная связность.

''Вычисляемые данные'':

<math>U = (u_1, u_2, ..., u_n)</math> - n-мерный вектор, где <math>u_i \in N_{[C]}</math> - порядковый номер кластера, к которому принадлежит вершина i исходного множества V.

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

Алгоритм имеет три вычислительных ядра, по одному на каждый этап.

На первом этапе вычислительным ядром является процесс нахождения <math>k</math> ближайших соседей для каждой вершины, который заключается в анализе матрицы расстояний.

На втором этапе вычислительным ядром является процесс поиска подходящего разбиения очередного подграфа на два графа с минимизацией разделителя ребер графа.

На третьем этапе вычислительным ядром является расчет величин <math>EC_{(C_{i},C_{j})}</math>, <math>S_{EC_{(C_{i},C_{j})}}</math>, <math>RI_{(C_{i},C_{j})} </math>, <math> RC_{(C_{i},C_{j})}</math> для каждой пары смежных кластеров.

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

Как уже рассказывалось ранее, алгоритм включает в себя три основных этапа, каждый из которых, по сути, является отдельным алгоритмом. Этапы выполняются последовательно относительно друг друга.

Макрооперация на первом этапе - процедура нахождения <math>k</math> ближайших соседей, на втором - процедура разбиения наибольшего подграфа на два графа, на третьем - процедура вычисления показателей сходства, на основе которых принимается решение о слиянии подграфов в кластер.

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

'''Первый этап'''
int n; //количество вершин
int k; //количество соседей
int A[n][n] //матрица расстояний
int D[k] //массив вершин-соседей
int E[n][n] //матрица ребер графа <math>G_{2} = (K, E_{2})</math>
for i=1 to n-1 do
{
for j=i+1 to n do
{
//заполняем массив вершин-соседей вставляя новые вершины, если они ближе, чем самая далекая из массива.
}
for j=0 to k do
{
//для каждой вершины соседа заполняем соответствующую ячейку из матрицы E[n][n] единицей
}

}

'''Второй этап'''

1. Все связные подграфы в отсортированном порядке помещаются в список;
2. Берем наибольший элемент списка, вычисляем количество его вершин. Если число вершин > l, то идем в пункт 3. Иначе в пункт 5;
3. Разбиваем подграф на два подграфа таким образом, чтобы разделитель ребер графа был минимален и каждый из получаемых подграфов содержал не менее 25 % вершин исходного графа;
4. Добавляем полученные элементы в список подграфов таким образом, чтобы список оставался отсортированным. Идем в пункт 2;
5. Нашли искомое множество подграфов math>K = \{K_{i}\}</math>;
6. Создаем и заполняем матрицу матрицу расстояний для графа <math>G_{2} = (K, E_{2})</math>. Получаем искомый набор рёбер <math>E_{2}</math>.

'''Третий этап'''

1. Заводим два массива: а) массив кластеров C, полученных на предыдущем этапе, б) массив объединений кластеров F, которые мы будем получать на этом этапе;
2. Берем следующий кластер <math>C_{i}</math> (на первом шаге - первый). Если все кластеры просмотрены, идем в пункт 6;
3. Берем следующий кластер <math>C_{j}, i<>j</math>. Если все кластеры просмотрены, то идем в пункт 2;
4. Проверяем смежность <math>C_{i}</math> и <math>C_{j}</math>. Если не смежны, то возвращаемся в пункт 3. Если смежны, идем в пункт 5;
5. Рассчитываем показатели <math>RI_{(C_{i},C_{j})}</math> и <math> RC_{(C_{i},C_{j})}</math>. Проверяем, удовлетворяют ли найденные значения условиям:
*<math>RI_{(C_{i},C_{j})} \geqslant T_{RI}</math>
*<math>RC_{(C_{i},C_{j})} \geqslant T_{RC}</math>
Если нет, то идем в пункт 3. Иначе если смежность пары кластеров выше, чем у предыдущих найденных, то <math>F_{i}=j</math>. Идем в пункт 3;
6. Если в списке F есть хотя бы одна пара кластеров для слияния, то выполняем слияние, обновляем массив кластеров и массив объединений кластеров. Идем в пункт 2.

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

1) Для построения графа на основе метода k ближайших соседей для n вершин требуется <math>O(n log(n))</math> операций [3]; для наборов данных большой размерности эта величина составляет <math>O(n^2)</math> операций [4];

2) Для выделения множества сравнительно малых связных подграфов требуется <math>nm</math> операций, где <math>m</math> - количество подграфов, полученных на втором этапе алгоритма;

3) Формирование набора кластеров, на основе множества подграфов, полученных на предыдущем этапе, требует <math>m^2log(m)</math> операций.

Итого, для n вершин получаем последовательную сложность <math>O(n log(n)+nm+m^2log(m))</math>.

== Информационный граф ==
[[File:СК.png]]

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

Первый этап работы алгоритма можно распределить между <math>n</math> процессами. На вход каждому процессу подается своя вершина, далее происходит процедура поиска <math>k</math> ближайших соседей. Параллельная сложность составляет <math>O(n)</math>.

Второй и третий этапы можно распараллелить частично.

Второй этап распараллеливается путем подачи на вход свободному процессу очередного подграфа для разделения. Число итераций оценивается в <math>O(n log(n))</math>.

Третий этап делится на расчет показателей схожести и соединение подграфов в кластеры. Процесс расчета показателей можно распараллелить, подавая каждому процессу на вход пару подграфов. Сложность этого процесса оценивается как <math>m log(m)</math>. Соединение подграфов в кластеры выполняется последовательно, сложность процесса составляет <math>m^2 log(m)</math>

Таким образом получаем общую параллельную сложность алгоритма: <math>O(n+ n log(n) + m^2 log (m) + m log(m))</math>

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

1. Симметрическая матрица <math>A</math> расстояний между элементами данных размера <math>n\times n</math> с нулями на главной диагонали (<math>a_{ii}= 0, i = 1, \ldots, N</math>).

2. <math>k</math> - количество ближайших соседей для вершин (рекомендуемое значение <math>k</math> от 5 до 20 в зависимости от количества анализируемых объектов).

3. <math>l</math> - наименьшее число вершин, которое может содержать наибольший подкластер на 2-м этапе . Величина этого параметра варьируется от 1 до 5 % от общего числа объектов.

'''Объём входных данных'''

<math>\frac{n (n - 1)}{2}</math> (в силу симметричности и нулевой главной диагонали достаточно хранить только над/поддиагональные элементы).

'''Выходные данные'''

Вектор из <math>n</math> чисел <math>u_{1}, u_{2}, \ldots, u_{N}</math>, где <math>u_{i}</math> - целое число, соответствующее кластеру <math>i</math>-го объекта.

'''Объём выходных данных'''

<math>n</math>

== Свойства алгоритма ==
Соотношение последовательной и параллельной сложности на первом этапе является ''линейным'' для больших наборов данных и логарифмическим для n вершин. На втором этапе сложно оценить это соотношение - оно сильно зависит от параметров <math>k</math> и <math>l</math>. На третьем этапе соотношение равно <math>O(1)</math>

Алгоритм является недетерминированным. Хотя 1-й этап детерминирован, на 2-ом этапе могут быть найдены различные разбиения на подграфы, что повлияет и на итоговый результат работы алгоритма.

= часть. Программная реализация алгоритма =
== ==
== ==
== ==
== Масштабируемость алгоритма и его реализации ==

см. позднее

== ==
== ==
== Существующие реализации алгоритма ==
Последовательная реализация алгоритма доступна по ссылке [5].

CHAMELEON можно реализовать с использованием графовых библиотек METIS [6], hMETIS [7] и RANN [8].

Существует исследование, связанное с реализацией CHAMELEON посредством технологии OpenMP, с которым можно ознакомиться здесь [9].

Параллельных реализаций алгоритма CHAMELEON не найдено.

= Литература =
[1] George Karypis, Eui-Hong (Sam) Han и Vipin Kumar, «Chameleon: Hierarchical Clustering Using Dynamic Modeling», 1999.

[2] http://studopedia.ru/7_41934_algoritm-dinamicheskoy-ierarhicheskoy-klasterizatsii-CHAMELEON.html

[3] J.H. Friedman, J.L. Bentley, and R.A. Finkel. An algorithm for ﬁnding best matches in logarithmic expected time. ACM Transactions on Mathematical Software, 3:209–226, 1977.

[4] S. Berchtold, C. Bohm, D. Keim, and H.-P. Kriegel. Cost model for nearest neighbor search in high dimensional data space. In Proc. of Symposium on Principles of Database Systems, Tucson, Arizona, 1997.

[5] http://www.codeforge.com/article/192925

[6] http://glaros.dtc.umn.edu/gkhome/metis/metis/overview

[7] http://glaros.dtc.umn.edu/gkhome/metis/hmetis/overview

[8] https://cran.r-project.org/web/packages/RANN/index.html

[9] http://research.ijcaonline.org/volume79/number8/pxc3891600.pdf

Участник:ЕкатеринаКозырева/Алгоритм динамической иерархической кластеризации CHAMELEON

2016-10-30T20:48:15Z

ЕкатеринаКозырева: /* часть. Программная реализация алгоритма */

{{algorithm
| name = Алгоритм динамической иерархической кластеризации CHAMELEON
| serial_complexity = <math>O(nm + n log n + m^2 log m)</math>
| input_data = <math>\frac{n (n - 1)}{2}</math>
| output_data = <math>n</math>
| pf_height = <math>O(n+ n log(n) + m^2 log (m) + m log(m))</math>
| pf_width = <math>O(n)</math>
}}

Автор описания [[Участник:ЕкатеринаКозырева|Е.А.Козырева]]
= Свойства и структура алгоритмов =

== Общее описание алгоритма ==
Алгоритм CHAMELEON был предложен в 1999 году тремя учеными из университета Миннесоты – George Karypis, Eui-Hong (Sam) Han и Vipin Kumar[1].

Предназначен для решения задач кластеризации. Кластеризация (или кластерный анализ) — это задача разбиения множества объектов на группы, называемые кластерами. Внутри каждой группы должны оказаться «похожие» объекты, а объекты разных группы должны быть как можно более отличны.

CHAMELEON - это агломеративный иерархический алгоритм кластеризации, ключевой особенностью которого является то, что он учитывает и взаимную связность, и сходство при определении наиболее похожей пары подкластеров, основываясь на динамической модели. Это означает, что в процессе кластеризации два кластера объединяются, только если их относительная взаимная связность и относительное взаимное сходство являются высокими по отношению к внутренней взаимосвязанности кластеров и близости элементов внутри кластеров. Кроме того, CHAMELEON использует подход для моделирования степени взаимосвязанности и близости между каждой парой кластеров, который учитывает внутренние характеристики самих кластеров. Таким образом, он может автоматически адаптироваться к внутренним характеристикам объединяемых кластеров.

CHAMELEON находит кластеры в наборе данных с помощью трехфазного алгоритма. На первой фазе происходит построение графа, путём добавления рёбер по принципу k ближайших соседей. На второй фазе CHAMELEON группирует полученные элементы в множество относительно небольших подграфов. Во время третьей фазы применяется агломеративный иерархический алгоритм кластеризации, с помощью которого находятся естесственные кластеры путем многократного объединения подграфов, полученных на прошлом этапе.

[[File:Chameleon.png]]

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

''Исходные данные'':

* Множество из n точек <math>V= {v_{ij}}</math> в метрическом пространстве, которое задано симметрической матрицей расстояний <math>A</math> размера <math>n\times n</math>.
* <math>k</math> - количество ближайших соседей для вершин, <math>k \in N, k \leq n</math>.
* <math>l</math> - наименьшее число вершин, которое может содержать наибольший подграф на 2-м этапе, <math>l \in N, l \leq n</math>.

''Обозначения'':

* <math>G = (V, E)</math> - граф, полученный путём соединения каждой точки с её <math>k</math> ближайшими соседями.

* <math>K= \{K_{i}\}</math> - разбиение множества <math>V</math> на набор попарно непересекающихся связных подмножеств, полученное в результате выполнения второй фазы алгоритма.

* <math>G_{2} = (K, E_{2})</math> - взвешенный граф, вершинами которого являются получившиеся подграфы, а ребрами - количество ребер исходного графа, соединяющих соответствующие подграфы.

* <math>C = \{C_{i}\}</math> - итоговое разбиение множества вершин графа <math>G_{2}</math> на набор кластеров.

''Вспомогательные понятия''

*<math>EC_{(C_{i},C_{j})}</math> - абсолютная взаимная связность пары кластеров <math>C_{i}, C{j}</math>. Определяется как сумма весов ребер, соединяющих вершины, принадлежащие <math>C{i}</math> c вершинами из <math>C{j}</math>. Внутренняя связность <math>EC_{(C_{i},C_{i})}</math> вычисляется как сумма ребер, входящих в разделитель, разбивающий <math>C{i}</math> на два равных подграфа.

*<math>RI_{(C_{i},C_{j})} = \frac{|EC_{(C_{i},C_{j})}|}{(|EC_{C_{i}}|+|EC_{C_{j}}|)/2}</math> - относительная взаимная связность пары кластеров <math>C_{i}, C{j}</math>

*<math>S_{EC_{(C_{i},C_{j})}}</math> - абсолютное взаимное сходство пары кластеров <math>C_{i}, C{j}</math>. Подсчитывается как среднее сходство между соединенными вершинами, принадлежащими <math>C{i}</math> и <math>C{j}</math> соответственно. Соединения обусловлены разбиением общего графа, полученного на первом этапе алгоритма.

*<math> RC_{(C_{i},C_{j})}= \frac{S_{EC_{(C_{i},C_{j})}}}{\frac{|C_{i}|}{|C_{i}+C_{j}|}*S_{EC_{(C_{i})}}+\frac{|C_{i}|}{|C_{i}+C_{j}|}*S_{EC_{(C_{j})}}}</math> - относительное взаимное сходство пары кластеров <math>C_{i}, C{j}</math>. Определяется как абсолютное сходство между этой парой кластеров, нормализованное с учетом их внутреннего сходства.

'''Первый этап'''

На первом этапе, согласно графо-ориентированному подходу, происходит построение графа <math>G = (V, E)</math> на матрице сходства объектов по принципу k ближайших соседей. Две вершины такого графа соединяет ребро, если объект, соответствующий любой из этих вершин попадает в число k наиболее близких объектов для объекта, соответствующего другой вершине из данной пары.
[[Файл:Снимок chameleon.PNG]]

'''Второй этап'''

Алгоритм разделяет полученный граф на множество сравнительно малых подграфов <math>K= \{K_{i}\}</math>. Разделение происходит последовательно. На каждом шаге выбирается подграф, содержащий наибольшее число вершин. Этот граф разделяется на два подграфа так, что разделитель ребер графа минимален и каждый из получаемых подграфов содержит не менее 25 % вершин исходного графа. Процесс разделения останавливается, когда наибольший подграф содержит меньше некоторого заданного числа вершин. Обычно величина этого параметра задается равной значению от 1 до 5 % от числа объектов. Полученное множество связных графов считается множеством начальных кластеров, на котором требуется провести последовательное иерархическое объединение.

'''Третий этап'''

Третий этап заключается в итеративном преобразовании множества подграфов <math>K= \{K_{i}\}</math> в множество кластеров <math>C = \{C_{i}\}</math>. Алгоритм осуществляет агломеративную иерархическую кластеризацию на основании показателей <math>EC_{(C_{i},C_{j})}</math>, <math>S_{EC_{(C_{i},C_{j})}}</math>, <math>RI_{(C_{i},C_{j})} </math>, <math> RC_{(C_{i},C_{j})}</math>. Существует две стратегии анализа показателей сходства. Первая подразумевает наличие некоторых пороговых значений <math>T_{RI}</math> и <math>T_{RC}</math>. В соответствии с этой стратегией, алгоритм для каждого кластера <math>C_{i}</math> проверяет, отвечают ли смежные (наиболее близкие) ему кластеры условиям:

*<math>RI_{(C_{i},C_{j})} \geqslant T_{RI}</math>

*<math>RC_{(C_{i},C_{j})} \geqslant T_{RC}</math>

Если более одного смежного кластера отвечает этим условиям, то алгоритм выбирает для объединения наиболее связный кластер (граф), то есть такой кластер <math>C_{j}</math>, с которым у кластера <math>C_{i}</math> получается наибольшая абсолютная взаимная связность. По завершению прохода по всем кластерам, созданные таким образом пары объединяются. Параметры <math>T_{RI}</math> и <math>T_{RC}</math> могут использоваться для изменения характеристик получаемых кластеров.

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

<math>RI_{(C_{i},C_{j})}*RC_{(C_{i},C_{j})}^\alpha</math>,

где <math>\alpha</math> выбирается пользователем. Если <math>\alpha > 1 </math>, то алгоритм придает большее значение относительному взаимному сходству, а если <math>\alpha < 1 </math>, то большее значение имеет относительная взаимная связность.

''Вычисляемые данные'':

<math>U = (u_1, u_2, ..., u_n)</math> - n-мерный вектор, где <math>u_i \in N_{[C]}</math> - порядковый номер кластера, к которому принадлежит вершина i исходного множества V.

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

Алгоритм имеет три вычислительных ядра, по одному на каждый этап.

На первом этапе вычислительным ядром является процесс нахождения <math>k</math> ближайших соседей для каждой вершины, который заключается в анализе матрицы расстояний.

На втором этапе вычислительным ядром является процесс поиска подходящего разбиения очередного подграфа на два графа с минимизацией разделителя ребер графа.

На третьем этапе вычислительным ядром является расчет величин <math>EC_{(C_{i},C_{j})}</math>, <math>S_{EC_{(C_{i},C_{j})}}</math>, <math>RI_{(C_{i},C_{j})} </math>, <math> RC_{(C_{i},C_{j})}</math> для каждой пары смежных кластеров.

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

Как уже рассказывалось ранее, алгоритм включает в себя три основных этапа, каждый из которых, по сути, является отдельным алгоритмом. Этапы выполняются последовательно относительно друг друга.

Макрооперация на первом этапе - процедура нахождения <math>k</math> ближайших соседей, на втором - процедура разбиения наибольшего подграфа на два графа, на третьем - процедура вычисления показателей сходства, на основе которых принимается решение о слиянии подграфов в кластер.

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

'''Первый этап'''
int n; //количество вершин
int k; //количество соседей
int A[n][n] //матрица расстояний
int D[k] //массив вершин-соседей
int E[n][n] //матрица ребер графа <math>G_{2} = (K, E_{2})</math>
for i=1 to n-1 do
{
for j=i+1 to n do
{
//заполняем массив вершин-соседей вставляя новые вершины, если они ближе, чем самая далекая из массива.
}
for j=0 to k do
{
//для каждой вершины соседа заполняем соответствующую ячейку из матрицы E[n][n] единицей
}

}

'''Второй этап'''

1. Все связные подграфы в отсортированном порядке помещаются в список;
2. Берем наибольший элемент списка, вычисляем количество его вершин. Если число вершин > l, то идем в пункт 3. Иначе в пункт 5;
3. Разбиваем подграф на два подграфа таким образом, чтобы разделитель ребер графа был минимален и каждый из получаемых подграфов содержал не менее 25 % вершин исходного графа;
4. Добавляем полученные элементы в список подграфов таким образом, чтобы список оставался отсортированным. Идем в пункт 2;
5. Нашли искомое множество подграфов math>K = \{K_{i}\}</math>;
6. Создаем и заполняем матрицу матрицу расстояний для графа <math>G_{2} = (K, E_{2})</math>. Получаем искомый набор рёбер <math>E_{2}</math>.

'''Третий этап'''

1. Заводим два массива: а) массив кластеров C, полученных на предыдущем этапе, б) массив объединений кластеров F, которые мы будем получать на этом этапе;
2. Берем следующий кластер <math>C_{i}</math> (на первом шаге - первый). Если все кластеры просмотрены, идем в пункт 6;
3. Берем следующий кластер <math>C_{j}, i<>j</math>. Если все кластеры просмотрены, то идем в пункт 2;
4. Проверяем смежность <math>C_{i}</math> и <math>C_{j}</math>. Если не смежны, то возвращаемся в пункт 3. Если смежны, идем в пункт 5;
5. Рассчитываем показатели <math>RI_{(C_{i},C_{j})}</math> и <math> RC_{(C_{i},C_{j})}</math>. Проверяем, удовлетворяют ли найденные значения условиям:
*<math>RI_{(C_{i},C_{j})} \geqslant T_{RI}</math>
*<math>RC_{(C_{i},C_{j})} \geqslant T_{RC}</math>
Если нет, то идем в пункт 3. Иначе если смежность пары кластеров выше, чем у предыдущих найденных, то <math>F_{i}=j</math>. Идем в пункт 3;
6. Если в списке F есть хотя бы одна пара кластеров для слияния, то выполняем слияние, обновляем массив кластеров и массив объединений кластеров. Идем в пункт 2.

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

1) Для построения графа на основе метода k ближайших соседей для n вершин требуется <math>O(n log(n))</math> операций [3]; для наборов данных большой размерности эта величина составляет <math>O(n^2)</math> операций [4];

2) Для выделения множества сравнительно малых связных подграфов требуется <math>nm</math> операций, где <math>m</math> - количество подграфов, полученных на втором этапе алгоритма;

3) Формирование набора кластеров, на основе множества подграфов, полученных на предыдущем этапе, требует <math>m^2log(m)</math> операций.

Итого, для n вершин получаем последовательную сложность <math>O(n log(n)+nm+m^2log(m))</math>.

== Информационный граф ==
[[File:СК.png]]

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

Первый этап работы алгоритма можно распределить между <math>n</math> процессами. На вход каждому процессу подается своя вершина, далее происходит процедура поиска <math>k</math> ближайших соседей. Параллельная сложность составляет <math>O(n)</math>.

Второй и третий этапы можно распараллелить частично.

Второй этап распараллеливается путем подачи на вход свободному процессу очередного подграфа для разделения. Число итераций оценивается в <math>O(n log(n))</math>.

Третий этап делится на расчет показателей схожести и соединение подграфов в кластеры. Процесс расчета показателей можно распараллелить, подавая каждому процессу на вход пару подграфов. Сложность этого процесса оценивается как <math>m log(m)</math>. Соединение подграфов в кластеры выполняется последовательно, сложность процесса составляет <math>m^2 log(m)</math>

Таким образом получаем общую параллельную сложность алгоритма: <math>O(n+ n log(n) + m^2 log (m) + m log(m))</math>

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

1. Симметрическая матрица <math>A</math> расстояний между элементами данных размера <math>n\times n</math> с нулями на главной диагонали (<math>a_{ii}= 0, i = 1, \ldots, N</math>).

2. <math>k</math> - количество ближайших соседей для вершин (рекомендуемое значение <math>k</math> от 5 до 20 в зависимости от количества анализируемых объектов).

3. <math>l</math> - наименьшее число вершин, которое может содержать наибольший подкластер на 2-м этапе . Величина этого параметра варьируется от 1 до 5 % от общего числа объектов.

'''Объём входных данных'''

<math>\frac{n (n - 1)}{2}</math> (в силу симметричности и нулевой главной диагонали достаточно хранить только над/поддиагональные элементы).

'''Выходные данные'''

Вектор из <math>n</math> чисел <math>u_{1}, u_{2}, \ldots, u_{N}</math>, где <math>u_{i}</math> - целое число, соответствующее кластеру <math>i</math>-го объекта.

'''Объём выходных данных'''

<math>n</math>

== Свойства алгоритма ==
Соотношение последовательной и параллельной сложности на первом этапе является ''линейным'' для больших наборов данных и логарифмическим для n вершин. На втором этапе сложно оценить это соотношение - оно сильно зависит от параметров <math>k</math> и <math>l</math>. На третьем этапе соотношение равно <math>O(1)</math>

Алгоритм является недетерминированным. Хотя 1-й этап детерминирован, на 2-ом этапе могут быть найдены различные разбиения на подграфы, что повлияет и на итоговый результат работы алгоритма.

= часть. Программная реализация алгоритма =
== ==
== ==
== ==
== Масштабируемость алгоритма и его реализации ==

см. позднее

== ==
== ==
== Существующие реализации алгоритма ==
Последовательная реализация алгоритма доступна по ссылке [5].

CHAMELEON можно реализовать с использованием графовых библиотек METIS [6], hMETIS [7] и RANN [8].

Существует исследование, связанное с реализацией CHAMELEON посредством технологии OpenMP, с которым можно ознакомиться здесь [9].

Параллельных реализаций алгоритма CHAMELEON не найдено.

= Литература =
[1] George Karypis, Eui-Hong (Sam) Han и Vipin Kumar, «Chameleon: Hierarchical Clustering Using Dynamic Modeling», 1999.

[2] http://studopedia.ru/7_41934_algoritm-dinamicheskoy-ierarhicheskoy-klasterizatsii-CHAMELEON.html

[3] J.H. Friedman, J.L. Bentley, and R.A. Finkel. An algorithm for ﬁnding best matches in logarithmic expected time. ACM Transactions on Mathematical Software, 3:209–226, 1977.

[4] S. Berchtold, C. Bohm, D. Keim, and H.-P. Kriegel. Cost model for nearest neighbor search in high dimensional data space. In Proc. of Symposium on Principles of Database Systems, Tucson, Arizona, 1997.

[5] http://www.codeforge.com/article/192925

[6] http://glaros.dtc.umn.edu/gkhome/metis/metis/overview

[7] http://glaros.dtc.umn.edu/gkhome/metis/hmetis/overview

[8] https://cran.r-project.org/web/packages/RANN/index.html

[9] http://research.ijcaonline.org/volume79/number8/pxc3891600.pdf

Участник:ЕкатеринаКозырева/Алгоритм динамической иерархической кластеризации CHAMELEON

2016-10-30T20:27:21Z

ЕкатеринаКозырева:

{{algorithm
| name = Алгоритм динамической иерархической кластеризации CHAMELEON
| serial_complexity = <math>O(nm + n log n + m^2 log m)</math>
| input_data = <math>\frac{n (n - 1)}{2}</math>
| output_data = <math>n</math>
| pf_height = <math>O(n+ n log(n) + m^2 log (m) + m log(m))</math>
| pf_width = <math>O(n)</math>
}}

Автор описания [[Участник:ЕкатеринаКозырева|Е.А.Козырева]]
= Свойства и структура алгоритмов =

== Общее описание алгоритма ==
Алгоритм CHAMELEON был предложен в 1999 году тремя учеными из университета Миннесоты – George Karypis, Eui-Hong (Sam) Han и Vipin Kumar[1].

Предназначен для решения задач кластеризации. Кластеризация (или кластерный анализ) — это задача разбиения множества объектов на группы, называемые кластерами. Внутри каждой группы должны оказаться «похожие» объекты, а объекты разных группы должны быть как можно более отличны.

CHAMELEON - это агломеративный иерархический алгоритм кластеризации, ключевой особенностью которого является то, что он учитывает и взаимную связность, и сходство при определении наиболее похожей пары подкластеров, основываясь на динамической модели. Это означает, что в процессе кластеризации два кластера объединяются, только если их относительная взаимная связность и относительное взаимное сходство являются высокими по отношению к внутренней взаимосвязанности кластеров и близости элементов внутри кластеров. Кроме того, CHAMELEON использует подход для моделирования степени взаимосвязанности и близости между каждой парой кластеров, который учитывает внутренние характеристики самих кластеров. Таким образом, он может автоматически адаптироваться к внутренним характеристикам объединяемых кластеров.

CHAMELEON находит кластеры в наборе данных с помощью трехфазного алгоритма. На первой фазе происходит построение графа, путём добавления рёбер по принципу k ближайших соседей. На второй фазе CHAMELEON группирует полученные элементы в множество относительно небольших подграфов. Во время третьей фазы применяется агломеративный иерархический алгоритм кластеризации, с помощью которого находятся естесственные кластеры путем многократного объединения подграфов, полученных на прошлом этапе.

[[File:Chameleon.png]]

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

''Исходные данные'':

* Множество из n точек <math>V= {v_{ij}}</math> в метрическом пространстве, которое задано симметрической матрицей расстояний <math>A</math> размера <math>n\times n</math>.
* <math>k</math> - количество ближайших соседей для вершин, <math>k \in N, k \leq n</math>.
* <math>l</math> - наименьшее число вершин, которое может содержать наибольший подграф на 2-м этапе, <math>l \in N, l \leq n</math>.

''Обозначения'':

* <math>G = (V, E)</math> - граф, полученный путём соединения каждой точки с её <math>k</math> ближайшими соседями.

* <math>K= \{K_{i}\}</math> - разбиение множества <math>V</math> на набор попарно непересекающихся связных подмножеств, полученное в результате выполнения второй фазы алгоритма.

* <math>G_{2} = (K, E_{2})</math> - взвешенный граф, вершинами которого являются получившиеся подграфы, а ребрами - количество ребер исходного графа, соединяющих соответствующие подграфы.

* <math>C = \{C_{i}\}</math> - итоговое разбиение множества вершин графа <math>G_{2}</math> на набор кластеров.

''Вспомогательные понятия''

*<math>EC_{(C_{i},C_{j})}</math> - абсолютная взаимная связность пары кластеров <math>C_{i}, C{j}</math>. Определяется как сумма весов ребер, соединяющих вершины, принадлежащие <math>C{i}</math> c вершинами из <math>C{j}</math>. Внутренняя связность <math>EC_{(C_{i},C_{i})}</math> вычисляется как сумма ребер, входящих в разделитель, разбивающий <math>C{i}</math> на два равных подграфа.

*<math>RI_{(C_{i},C_{j})} = \frac{|EC_{(C_{i},C_{j})}|}{(|EC_{C_{i}}|+|EC_{C_{j}}|)/2}</math> - относительная взаимная связность пары кластеров <math>C_{i}, C{j}</math>

*<math>S_{EC_{(C_{i},C_{j})}}</math> - абсолютное взаимное сходство пары кластеров <math>C_{i}, C{j}</math>. Подсчитывается как среднее сходство между соединенными вершинами, принадлежащими <math>C{i}</math> и <math>C{j}</math> соответственно. Соединения обусловлены разбиением общего графа, полученного на первом этапе алгоритма.

*<math> RC_{(C_{i},C_{j})}= \frac{S_{EC_{(C_{i},C_{j})}}}{\frac{|C_{i}|}{|C_{i}+C_{j}|}*S_{EC_{(C_{i})}}+\frac{|C_{i}|}{|C_{i}+C_{j}|}*S_{EC_{(C_{j})}}}</math> - относительное взаимное сходство пары кластеров <math>C_{i}, C{j}</math>. Определяется как абсолютное сходство между этой парой кластеров, нормализованное с учетом их внутреннего сходства.

'''Первый этап'''

На первом этапе, согласно графо-ориентированному подходу, происходит построение графа <math>G = (V, E)</math> на матрице сходства объектов по принципу k ближайших соседей. Две вершины такого графа соединяет ребро, если объект, соответствующий любой из этих вершин попадает в число k наиболее близких объектов для объекта, соответствующего другой вершине из данной пары.
[[Файл:Снимок chameleon.PNG]]

'''Второй этап'''

Алгоритм разделяет полученный граф на множество сравнительно малых подграфов <math>K= \{K_{i}\}</math>. Разделение происходит последовательно. На каждом шаге выбирается подграф, содержащий наибольшее число вершин. Этот граф разделяется на два подграфа так, что разделитель ребер графа минимален и каждый из получаемых подграфов содержит не менее 25 % вершин исходного графа. Процесс разделения останавливается, когда наибольший подграф содержит меньше некоторого заданного числа вершин. Обычно величина этого параметра задается равной значению от 1 до 5 % от числа объектов. Полученное множество связных графов считается множеством начальных кластеров, на котором требуется провести последовательное иерархическое объединение.

'''Третий этап'''

Третий этап заключается в итеративном преобразовании множества подграфов <math>K= \{K_{i}\}</math> в множество кластеров <math>C = \{C_{i}\}</math>. Алгоритм осуществляет агломеративную иерархическую кластеризацию на основании показателей <math>EC_{(C_{i},C_{j})}</math>, <math>S_{EC_{(C_{i},C_{j})}}</math>, <math>RI_{(C_{i},C_{j})} </math>, <math> RC_{(C_{i},C_{j})}</math>. Существует две стратегии анализа показателей сходства. Первая подразумевает наличие некоторых пороговых значений <math>T_{RI}</math> и <math>T_{RC}</math>. В соответствии с этой стратегией, алгоритм для каждого кластера <math>C_{i}</math> проверяет, отвечают ли смежные (наиболее близкие) ему кластеры условиям:

*<math>RI_{(C_{i},C_{j})} \geqslant T_{RI}</math>

*<math>RC_{(C_{i},C_{j})} \geqslant T_{RC}</math>

Если более одного смежного кластера отвечает этим условиям, то алгоритм выбирает для объединения наиболее связный кластер (граф), то есть такой кластер <math>C_{j}</math>, с которым у кластера <math>C_{i}</math> получается наибольшая абсолютная взаимная связность. По завершению прохода по всем кластерам, созданные таким образом пары объединяются. Параметры <math>T_{RI}</math> и <math>T_{RC}</math> могут использоваться для изменения характеристик получаемых кластеров.

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

<math>RI_{(C_{i},C_{j})}*RC_{(C_{i},C_{j})}^\alpha</math>,

где <math>\alpha</math> выбирается пользователем. Если <math>\alpha > 1 </math>, то алгоритм придает большее значение относительному взаимному сходству, а если <math>\alpha < 1 </math>, то большее значение имеет относительная взаимная связность.

''Вычисляемые данные'':

<math>U = (u_1, u_2, ..., u_n)</math> - n-мерный вектор, где <math>u_i \in N_{[C]}</math> - порядковый номер кластера, к которому принадлежит вершина i исходного множества V.

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

Алгоритм имеет три вычислительных ядра, по одному на каждый этап.

На первом этапе вычислительным ядром является процесс нахождения <math>k</math> ближайших соседей для каждой вершины, который заключается в анализе матрицы расстояний.

На втором этапе вычислительным ядром является процесс поиска подходящего разбиения очередного подграфа на два графа с минимизацией разделителя ребер графа.

На третьем этапе вычислительным ядром является расчет величин <math>EC_{(C_{i},C_{j})}</math>, <math>S_{EC_{(C_{i},C_{j})}}</math>, <math>RI_{(C_{i},C_{j})} </math>, <math> RC_{(C_{i},C_{j})}</math> для каждой пары смежных кластеров.

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

Как уже рассказывалось ранее, алгоритм включает в себя три основных этапа, каждый из которых, по сути, является отдельным алгоритмом. Этапы выполняются последовательно относительно друг друга.

Макрооперация на первом этапе - процедура нахождения <math>k</math> ближайших соседей, на втором - процедура разбиения наибольшего подграфа на два графа, на третьем - процедура вычисления показателей сходства, на основе которых принимается решение о слиянии подграфов в кластер.

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

'''Первый этап'''
int n; //количество вершин
int k; //количество соседей
int A[n][n] //матрица расстояний
int D[k] //массив вершин-соседей
int E[n][n] //матрица ребер графа <math>G_{2} = (K, E_{2})</math>
for i=1 to n-1 do
{
for j=i+1 to n do
{
//заполняем массив вершин-соседей вставляя новые вершины, если они ближе, чем самая далекая из массива.
}
for j=0 to k do
{
//для каждой вершины соседа заполняем соответствующую ячейку из матрицы E[n][n] единицей
}

}

'''Второй этап'''

1. Все связные подграфы в отсортированном порядке помещаются в список;
2. Берем наибольший элемент списка, вычисляем количество его вершин. Если число вершин > l, то идем в пункт 3. Иначе в пункт 5;
3. Разбиваем подграф на два подграфа таким образом, чтобы разделитель ребер графа был минимален и каждый из получаемых подграфов содержал не менее 25 % вершин исходного графа;
4. Добавляем полученные элементы в список подграфов таким образом, чтобы список оставался отсортированным. Идем в пункт 2;
5. Нашли искомое множество подграфов math>K = \{K_{i}\}</math>;
6. Создаем и заполняем матрицу матрицу расстояний для графа <math>G_{2} = (K, E_{2})</math>. Получаем искомый набор рёбер <math>E_{2}</math>.

'''Третий этап'''

1. Заводим два массива: а) массив кластеров C, полученных на предыдущем этапе, б) массив объединений кластеров F, которые мы будем получать на этом этапе;
2. Берем следующий кластер <math>C_{i}</math> (на первом шаге - первый). Если все кластеры просмотрены, идем в пункт 6;
3. Берем следующий кластер <math>C_{j}, i<>j</math>. Если все кластеры просмотрены, то идем в пункт 2;
4. Проверяем смежность <math>C_{i}</math> и <math>C_{j}</math>. Если не смежны, то возвращаемся в пункт 3. Если смежны, идем в пункт 5;
5. Рассчитываем показатели <math>RI_{(C_{i},C_{j})}</math> и <math> RC_{(C_{i},C_{j})}</math>. Проверяем, удовлетворяют ли найденные значения условиям:
*<math>RI_{(C_{i},C_{j})} \geqslant T_{RI}</math>
*<math>RC_{(C_{i},C_{j})} \geqslant T_{RC}</math>
Если нет, то идем в пункт 3. Иначе если смежность пары кластеров выше, чем у предыдущих найденных, то <math>F_{i}=j</math>. Идем в пункт 3;
6. Если в списке F есть хотя бы одна пара кластеров для слияния, то выполняем слияние, обновляем массив кластеров и массив объединений кластеров. Идем в пункт 2.

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

1) Для построения графа на основе метода k ближайших соседей для n вершин требуется <math>O(n log(n))</math> операций [3]; для наборов данных большой размерности эта величина составляет <math>O(n^2)</math> операций [4];

2) Для выделения множества сравнительно малых связных подграфов требуется <math>nm</math> операций, где <math>m</math> - количество подграфов, полученных на втором этапе алгоритма;

3) Формирование набора кластеров, на основе множества подграфов, полученных на предыдущем этапе, требует <math>m^2log(m)</math> операций.

Итого, для n вершин получаем последовательную сложность <math>O(n log(n)+nm+m^2log(m))</math>.

== Информационный граф ==
[[File:СК.png]]

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

Первый этап работы алгоритма можно распределить между <math>n</math> процессами. На вход каждому процессу подается своя вершина, далее происходит процедура поиска <math>k</math> ближайших соседей. Параллельная сложность составляет <math>O(n)</math>.

Второй и третий этапы можно распараллелить частично.

Второй этап распараллеливается путем подачи на вход свободному процессу очередного подграфа для разделения. Число итераций оценивается в <math>O(n log(n))</math>.

Третий этап делится на расчет показателей схожести и соединение подграфов в кластеры. Процесс расчета показателей можно распараллелить, подавая каждому процессу на вход пару подграфов. Сложность этого процесса оценивается как <math>m log(m)</math>. Соединение подграфов в кластеры выполняется последовательно, сложность процесса составляет <math>m^2 log(m)</math>

Таким образом получаем общую параллельную сложность алгоритма: <math>O(n+ n log(n) + m^2 log (m) + m log(m))</math>

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

1. Симметрическая матрица <math>A</math> расстояний между элементами данных размера <math>n\times n</math> с нулями на главной диагонали (<math>a_{ii}= 0, i = 1, \ldots, N</math>).

2. <math>k</math> - количество ближайших соседей для вершин (рекомендуемое значение <math>k</math> от 5 до 20 в зависимости от количества анализируемых объектов).

3. <math>l</math> - наименьшее число вершин, которое может содержать наибольший подкластер на 2-м этапе . Величина этого параметра варьируется от 1 до 5 % от общего числа объектов.

'''Объём входных данных'''

<math>\frac{n (n - 1)}{2}</math> (в силу симметричности и нулевой главной диагонали достаточно хранить только над/поддиагональные элементы).

'''Выходные данные'''

Вектор из <math>n</math> чисел <math>u_{1}, u_{2}, \ldots, u_{N}</math>, где <math>u_{i}</math> - целое число, соответствующее кластеру <math>i</math>-го объекта.

'''Объём выходных данных'''

<math>n</math>

== Свойства алгоритма ==
Соотношение последовательной и параллельной сложности на первом этапе является ''линейным'' для больших наборов данных и логарифмическим для n вершин. На втором этапе сложно оценить это соотношение - оно сильно зависит от параметров <math>k</math> и <math>l</math>. На третьем этапе соотношение равно <math>O(1)</math>

Алгоритм является недетерминированным. Хотя 1-й этап детерминирован, на 2-ом этапе могут быть найдены различные разбиения на подграфы, что повлияет и на итоговый результат работы алгоритма.

= часть. Программная реализация алгоритма =
== Масштабируемость алгоритма и его реализации ==

см. позднее

== Существующие реализации алгоритма ==
Последовательная реализация алгоритма доступна по ссылке [5].

CHAMELEON можно реализовать с использованием графовых библиотек METIS [6], hMETIS [7] и RANN [8].

Существует исследование, связанное с реализацией CHAMELEON посредством технологии OpenMP, с которым можно ознакомиться здесь [9].

Параллельных реализаций алгоритма CHAMELEON не найдено.

= Литература =
[1] George Karypis, Eui-Hong (Sam) Han и Vipin Kumar, «Chameleon: Hierarchical Clustering Using Dynamic Modeling», 1999.

[2] http://studopedia.ru/7_41934_algoritm-dinamicheskoy-ierarhicheskoy-klasterizatsii-CHAMELEON.html

[3] J.H. Friedman, J.L. Bentley, and R.A. Finkel. An algorithm for ﬁnding best matches in logarithmic expected time. ACM Transactions on Mathematical Software, 3:209–226, 1977.

[4] S. Berchtold, C. Bohm, D. Keim, and H.-P. Kriegel. Cost model for nearest neighbor search in high dimensional data space. In Proc. of Symposium on Principles of Database Systems, Tucson, Arizona, 1997.

[5] http://www.codeforge.com/article/192925

[6] http://glaros.dtc.umn.edu/gkhome/metis/metis/overview

[7] http://glaros.dtc.umn.edu/gkhome/metis/hmetis/overview

[8] https://cran.r-project.org/web/packages/RANN/index.html

[9] http://research.ijcaonline.org/volume79/number8/pxc3891600.pdf