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

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

2017-02-04T11:16:20Z

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

{{assignment}}
Автор статьи: Хромов А. К.

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

=== Общее описание алгоритма ===
Алгоритм CHAMELEON - алгоритм динамической иерархической кластеризации графа.
<ref name="studo">http://studopedia.ru/7_41934_algoritm-dinamicheskoy-ierarhicheskoy-klasterizatsii-CHAMELEON.html</ref>
Кластеризация - разбиение графа на несколько подграфов таким образом, чтобы объекты внутри одного кластера были максимально близки (схожи), а данные двух различных кластеров максимально различались. Различие и схожесть объектов определяются некоей метрикой, известной заранее. Количество кластеров, на которые будет разбит граф, заранее неизвестно, и зависит от свойств объекта и выбранной метрики. Простейшей возможной метриков является расстояние между точками (если предполагать, что у каждой вершины графа есть координаты).

Алгоритм состоит из 3-х основных этапов:

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

2-й этап заключается в разбиении построенного графа на небольшие кластеры (связные подграфы)

3-й этап состоит в формировании итогового множества кластеров

=== Математическое описание алгоритма ===
'''Исходные данные'''

Множество из n объектов и заданные расстояния между объектами. Эта информация позволяет построить матрицу смежности, в которой будут указаны расстояния между соответствующими объектами по некой метрике. Матрица смежности симметрична, на главной диагонали стоят 0, поэтому достаточно хранить <math>\frac{n(n-1)}{2}</math> элементов. Кроме того задаются параметры, влияющие на работу алгоритма - число k, по которому на первом этапе строится граф по принципу k ближайших соседей, и два параметра <math>{T_{ri}}</math> и <math>{T_{rc}}</math>, используемые на третьем этапе для того, что определить, что не нужно далее продолжать кластеризацию.

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

На первом этапе строится граф <math>G(V,E)</math>, <math>V</math> - множество вершин, <math>E</math> - множество ребер, по принципу k ближайших соседей. Изначально граф состоит из множества вершин и пустого множества ребер. Для каждой вершины графа мы выбираем k других вершин, расстояния до которых минимальны (то есть k первых вершин в списке вершин графа, упорядоченных по увеличению расстояния до данной) и добавляем в множество ребер соответствующие ребра, соединяющие данную вершину с каждой из выбранных k вершин.

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

Состоит в итеративном разбиении графа на множество подграфов. Изначально (на первой итерации) разбиение состоит из единственного подграфа. Пусть <math>T</math> - множество подграфов на текущей итерации. Каждая итерация выполняется следующим образом - выбирается максимальный подграф из имеющихся в разбиении по числу вершин (то есть такой подграф <math>G_1(V_1,E_1)\in{T}: \forall {G_2(V_2,E_2)\in{T}: G_2\neq G_1} => |(V_1)|>|(V_2)|</math> ). Выбранный подграф разбивается на 2 подграфа следующим образом - сначала выбираются все разбиения <math>G_2(V_2,E_2)</math> и <math>G_3(V_3,E_3)</math>, такие, что <math>\min(|V_2|,|V_3|)\geq\frac{|V_1|}{4}</math>. Далее среди всех таких разбиений выбирается такое, для которого величина <math>\sum{|E_1^*|},E_1^* </math>- некое ребро, ведущее из вершины, попавшей в <math>G_2</math> в вершину, попавшую в <math>G_3</math>. В определенный момент, когда размер наибольшего кластера <math>|V_b|\leq{q*|V|}</math>, где <math>|V|</math> - количество вершин в изначальном графе, а <math>q</math> - предварительно заданный параметр, процесс дальнейшего разибения прекращается и алгоритм переходи на 3-й этап

'''Третий этап алгоритма:'''

Введем несколько определений:

Абсолютной взаимной связностью пары кластеров называется величина <math>EC_{({C_i},{C_j})}</math>, вычисляется как сумма весов ребер, соединяющих вершина 1-го кластера <math>C_i</math> с вершинами второго кластера <math>C_j</math>. Внутренняя связность кластера <math>E_{C_i}</math>вычисляется как сумма весов ребер, входящих в разделитель, разбивающих <math>C_i</math> на 2 равных подграфа.

Относительная взаимная связность пары кластеров <math>RI_{(C_i,C_j)}</math> вычисляется по формуле <math>RI_{(C_i,C_j)}=\frac{2*|EC_{(C_i,C_j)}|}{|EC_{C_i}|+|EC_{C_j}|}</math>

Абсолютное взаимное сходство пары кластеров <math>S_{E_{(C_i,C_j)}}</math>вычисляется как среднее сходство между связанными вершинами <math>C_i</math> и <math>C_j</math>

Относительное взаимное сходство пары кластеров <math>C_i</math> и <math>C_j</math> обозначается <math>RC_{(C_i,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_j|}{|C_i|+|C_j|}*S_{EC_{(C_j)}}}}</math>

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

Есть два различных подхода анализа сходства.

Первый - для каждой пары кластеров проверяется истинность следующих высказываний

<math>RI(Ci,Cj)\geq{T_{RI}} </math> и <math>RC_{(C_{i},C_{j})}\geq{T_{RC}}</math>

В случае, если для некоторого <math>C_i</math> существует несколько кластеров <math>C_j</math>, удовлетворяющих этим условиям, выбирается такой <math>C_j</math>, что

значение <math>EC_{(C_i,C_j)}</math> максимально.

Процесс останавливается, когда нет кластеров, удовлетворяющих указанным условиям (либо когда остался только 1 кластер)

Второй подход - выбирается такая пара кластеров, что <math>RI_{(C_i,C_j)}*RC^\alpha_{(C_i,C_j)}</math> максимально, где <math>\alpha</math> - заданный заранее параметр.

Процесс останавливается, когда нет кластеров, удовлетворяющих указанным условиям (либо когда остался только 1 кластер)
<ref name="chamel">http://www-users.cs.umn.edu/~han/dmclass/chameleon.pdf</ref>

=== Вычислительное ядро алгоритма ===
На первом этапе вычислительное ядро состоит из построения графа k ближайших соседей по исходной матрице смежности (требуется для каждой вершины перебрать всех соседей и выделить k ближайших)

На втором этапе вычислительное ядро состоит из повторяющегося нахождения разбиения графа на два подграфа, удовлетворяющего ранее описанным условиям

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

=== Макроструктура алгоритма ===
1. Построение графа k-ближайших соседей по исходным данным

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

3. Итеративно осуществляется обхединение подграфов, на основе метрик взаимной связности и взаимного сходства. Процесс объединения завершается в момент достижения целевых показателей по данным метрикам.

=== Схема реализации последовательного алгоритма ===
Схема представлена в виде C++-подобного псевдокода, макрооперации в алгоритме выделены в соответствии с предыдущим разделом описания.
int n; // Количество точек.
int k; // Параметр k
int Dist[n][n]; // Матрица расстояний между точками.

integer E[n][n]; // Матрица рёбер графа

foreach (int i=0; i<n; i++) ) {
integer KNeighbours[k]; // список, используемый для хранения ближайших соседей
integer countN = 0;

foreach (int j=i+1; j<n; j++ ) {
//Заполняем список k ближайших соседей по матрице Dist
}

foreach (int j=0; j<k; j++) {
E[i][KNeighbours[j]] = 1;
}
}
return E;

double q; //Параметр, описание находится в соответствующем разделе.
Graph g = getBiggestGraph(); //Находим граф максимального размера
int maxSize = getSize(g); //Находим размер данного графа
while (maxSize > n * q) {
breakGraph(g); // Разбиваем граф
}

Graph graphs[m]; //Разбиение по кластерам
while (count(graphs)>1){
pairs_exist = false //Значение будет обновлено позже, если найдется подходящая пара для объединения
for (int i = 0; i < m; i++) {
for (int j = i + 1; j < m; j++) {
if (checkSimilarity(graphs[i],graphs[j])) { //Проверяем, достаточно ли схожи графы для объединения
unite(graphs[i], graphs[l])
} else {
break;
}
}
}
}

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

На втором этапе для итеративного разбиения требуется <math>O(nm)</math>операций, где <math>n</math> - количество вершин графа, а <math>m</math> - количество подграфов в итоговом разбиении.

На третьем этапе требуется <math>O(m^2logm)</math> операций, причем вычисление метрики считается за одну операцию.

Итоговая оценка последовательной сложности <math>O(n^2)+O(nm)+O(m^2logm)</math>

=== Информационный граф ===
[[Файл:Инфограф.png]]

=== Ресурс параллелизма алгоритма ===
На первом этапе вычисление <math>k</math> ближайших вершин для <math>i</math>-й вершины можно распараллелить между <math>n</math> процессами (это вычисление независимо для каждой вершины).
На втором и третьем этапах процессы разбиения и объединения подграфов происходят последовательно.
Получаем оценку параллельной сложности алгоритма <math>O(nm)+O(m^2logm)</math>

=== Входные и выходные данные алгоритма ===
На вход алгоритму подается множество из <math>n</math> векторов длины <math>l</math>, описывающих объекты для кластеризации.
Также передаются параметры <math>k</math> (для построения графа k ближайших соседей на первом этапе) и <math>q</math> (используется на втором этапе для определения критерия прекращения итерационного процесса).
На выходе алгоритм выдает массив длины <math>n</math>, заполненный числами от <math>1</math> до <math>n</math>, показывающими, в какой кластер попал соответствующий объект.

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

Вычислительная мощность (соотношение времени выполнения и объема входных и выходных данных) для разных этапов:

<math>O(1)</math> для первого этапа

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

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

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

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

Реализации алгоритма Chameleon для систем с распределенной памятью найдено не было, но была найдена параллельная реализация для систем с общей памятью <ref name="real">http://research.ijcaonline.org/volume79/number8/pxc3891600.pdf</ref>. Для данной реализации авторы приводят информацию о производительности, но не приводят исходный код программы. По этой причине была исследована масштабируемость алгоритма в зависимости от количества точек для кластеризации для реализации в пределах одного узла для реализации <ref name="rel_code">http://www.codeforge.com/article/192925</ref>. Запуск программы осуществлялся на вычислительном комплексе IBM Blue Gene/P на одном узле. Характеристики узла приведены по ссылке <ref name="har">http://hpc.cmc.msu.ru/bgp</ref>.
Далее приведены графики зависимости времени работы программы от размера входных данных. Графики для 4-х и 8 процессов оценочны.

[[Файл:718bad6be0fe40419c7ad15675f079f4.png|600px]]

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

===Динамические характеристики и эффективность реализации алгоритма===
===Выводы для классов архитектур===
===Существующие реализации алгоритма===
Одна из последовательных реализаций алгоритма находится по ссылке [http://codeforge.com/article/192925]

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

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

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

2017-02-03T15:06:55Z

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

{{assignment}}
Автор статьи: Хромов А. К.

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

=== Общее описание алгоритма ===
Алгоритм CHAMELEON - алгоритм динамической иерархической кластеризации графа.
<ref name="studo">http://studopedia.ru/7_41934_algoritm-dinamicheskoy-ierarhicheskoy-klasterizatsii-CHAMELEON.html</ref>
Кластеризация - разбиение графа на несколько подграфов таким образом, чтобы объекты внутри одного кластера были максимально близки (схожи), а данные двух различных кластеров максимально различались. Различие и схожесть объектов определяются некоей метрикой, известной заранее. Количество кластеров, на которые будет разбит граф, заранее неизвестно, и зависит от свойств объекта и выбранной метрики. Простейшей возможной метриков является расстояние между точками (если предполагать, что у каждой вершины графа есть координаты).

Алгоритм состоит из 3-х основных этапов:

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

2-й этап заключается в разбиении построенного графа на небольшие кластеры (связные подграфы)

3-й этап состоит в формировании итогового множества кластеров

=== Математическое описание алгоритма ===
'''Исходные данные'''

Множество из n объектов и заданные расстояния между объектами. Эта информация позволяет построить матрицу смежности, в которой будут указаны расстояния между соответствующими объектами по некой метрике. Матрица смежности симметрична, на главной диагонали стоят 0, поэтому достаточно хранить <math>\frac{n(n-1)}{2}</math> элементов. Кроме того задаются параметры, влияющие на работу алгоритма - число k, по которому на первом этапе строится граф по принципу k ближайших соседей, и два параметра <math>{T_{ri}}</math> и <math>{T_{rc}}</math>, используемые на третьем этапе для того, что определить, что не нужно далее продолжать кластеризацию.

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

На первом этапе строится граф <math>G(V,E)</math>, <math>V</math> - множество вершин, <math>E</math> - множество ребер, по принципу k ближайших соседей. Изначально граф состоит из множества вершин и пустого множества ребер. Для каждой вершины графа мы выбираем k других вершин, расстояния до которых минимальны (то есть k первых вершин в списке вершин графа, упорядоченных по увеличению расстояния до данной) и добавляем в множество ребер соответствующие ребра, соединяющие данную вершину с каждой из выбранных k вершин.

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

Состоит в итеративном разбиении графа на множество подграфов. Изначально (на первой итерации) разбиение состоит из единственного подграфа. Пусть <math>T</math> - множество подграфов на текущей итерации. Каждая итерация выполняется следующим образом - выбирается максимальный подграф из имеющихся в разбиении по числу вершин (то есть такой подграф <math>G_1(V_1,E_1)\in{T}: \forall {G_2(V_2,E_2)\in{T}: G_2\neq G_1} => |(V_1)|>|(V_2)|</math> ). Выбранный подграф разбивается на 2 подграфа следующим образом - сначала выбираются все разбиения <math>G_2(V_2,E_2)</math> и <math>G_3(V_3,E_3)</math>, такие, что <math>\min(|V_2|,|V_3|)\geq\frac{|V_1|}{4}</math>. Далее среди всех таких разбиений выбирается такое, для которого величина <math>\sum{|E_1^*|},E_1^* </math>- некое ребро, ведущее из вершины, попавшей в <math>G_2</math> в вершину, попавшую в <math>G_3</math>. В определенный момент, когда размер наибольшего кластера <math>|V_b|\leq{q*|V|}</math>, где <math>|V|</math> - количество вершин в изначальном графе, а <math>q</math> - предварительно заданный параметр, процесс дальнейшего разибения прекращается и алгоритм переходи на 3-й этап

'''Третий этап алгоритма:'''

Введем несколько определений:

Абсолютной взаимной связностью пары кластеров называется величина <math>EC_{({C_i},{C_j})}</math>, вычисляется как сумма весов ребер, соединяющих вершина 1-го кластера <math>C_i</math> с вершинами второго кластера <math>C_j</math>. Внутренняя связность кластера <math>E_{C_i}</math>вычисляется как сумма весов ребер, входящих в разделитель, разбивающих <math>C_i</math> на 2 равных подграфа.

Относительная взаимная связность пары кластеров <math>RI_{(C_i,C_j)}</math> вычисляется по формуле <math>RI_{(C_i,C_j)}=\frac{2*|EC_{(C_i,C_j)}|}{|EC_{C_i}|+|EC_{C_j}|}</math>

Абсолютное взаимное сходство пары кластеров <math>S_{E_{(C_i,C_j)}}</math>вычисляется как среднее сходство между связанными вершинами <math>C_i</math> и <math>C_j</math>

Относительное взаимное сходство пары кластеров <math>C_i</math> и <math>C_j</math> обозначается <math>RC_{(C_i,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_j|}{|C_i|+|C_j|}*S_{EC_{(C_j)}}}}</math>

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

Есть два различных подхода анализа сходства.

Первый - для каждой пары кластеров проверяется истинность следующих высказываний

<math>RI(Ci,Cj)\geq{T_{RI}} </math> и <math>RC_{(C_{i},C_{j})}\geq{T_{RC}}</math>

В случае, если для некоторого <math>C_i</math> существует несколько кластеров <math>C_j</math>, удовлетворяющих этим условиям, выбирается такой <math>C_j</math>, что

значение <math>EC_{(C_i,C_j)}</math> максимально.

Процесс останавливается, когда нет кластеров, удовлетворяющих указанным условиям (либо когда остался только 1 кластер)

Второй подход - выбирается такая пара кластеров, что <math>RI_{(C_i,C_j)}*RC^\alpha_{(C_i,C_j)}</math> максимально, где <math>\alpha</math> - заданный заранее параметр.

Процесс останавливается, когда нет кластеров, удовлетворяющих указанным условиям (либо когда остался только 1 кластер)
<ref name="chamel">http://www-users.cs.umn.edu/~han/dmclass/chameleon.pdf</ref>

=== Вычислительное ядро алгоритма ===
На первом этапе вычислительное ядро состоит из построения графа k ближайших соседей по исходной матрице смежности (требуется для каждой вершины перебрать всех соседей и выделить k ближайших)

На втором этапе вычислительное ядро состоит из повторяющегося нахождения разбиения графа на два подграфа, удовлетворяющего ранее описанным условиям

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

=== Макроструктура алгоритма ===
1. Построение графа k-ближайших соседей по исходным данным

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

3. Итеративно осуществляется обхединение подграфов, на основе метрик взаимной связности и взаимного сходства. Процесс объединения завершается в момент достижения целевых показателей по данным метрикам.

=== Схема реализации последовательного алгоритма ===
Схема представлена в виде C++-подобного псевдокода, макрооперации в алгоритме выделены в соответствии с предыдущим разделом описания.
int n; // Количество точек.
int k; // Параметр k
int Dist[n][n]; // Матрица расстояний между точками.

integer E[n][n]; // Матрица рёбер графа

foreach (int i=0; i<n; i++) ) {
integer KNeighbours[k]; // список, используемый для хранения ближайших соседей
integer countN = 0;

foreach (int j=i+1; j<n; j++ ) {
//Заполняем список k ближайших соседей по матрице Dist
}

foreach (int j=0; j<k; j++) {
E[i][KNeighbours[j]] = 1;
}
}
return E;

double q; //Параметр, описание находится в соответствующем разделе.
Graph g = getBiggestGraph(); //Находим граф максимального размера
int maxSize = getSize(g); //Находим размер данного графа
while (maxSize > n * q) {
breakGraph(g); // Разбиваем граф
}

Graph graphs[m]; //Разбиение по кластерам
while (count(graphs)>1){
pairs_exist = false //Значение будет обновлено позже, если найдется подходящая пара для объединения
for (int i = 0; i < m; i++) {
for (int j = i + 1; j < m; j++) {
if (checkSimilarity(graphs[i],graphs[j])) { //Проверяем, достаточно ли схожи графы для объединения
unite(graphs[i], graphs[l])
} else {
break;
}
}
}
}

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

На втором этапе для итеративного разбиения требуется <math>O(nm)</math>операций, где <math>n</math> - количество вершин графа, а <math>m</math> - количество подграфов в итоговом разбиении.

На третьем этапе требуется <math>O(m^2logm)</math> операций, причем вычисление метрики считается за одну операцию.

Итоговая оценка последовательной сложности <math>O(n^2)+O(nm)+O(m^2logm)</math>

=== Информационный граф ===
[[Файл:Инфограф.png]]

=== Ресурс параллелизма алгоритма ===
На первом этапе вычисление <math>k</math> ближайших вершин для <math>i</math>-й вершины можно распараллелить между <math>n</math> процессами (это вычисление независимо для каждой вершины).
На втором и третьем этапах процессы разбиения и объединения подграфов происходят последовательно.
Получаем оценку параллельной сложности алгоритма <math>O(nm)+O(m^2logm)</math>

=== Входные и выходные данные алгоритма ===
На вход алгоритму подается множество из <math>n</math> векторов длины <math>l</math>, описывающих объекты для кластеризации.
Также передаются параметры <math>k</math> (для построения графа k ближайших соседей на первом этапе) и <math>q</math> (используется на втором этапе для определения критерия прекращения итерационного процесса).
На выходе алгоритм выдает массив длины <math>n</math>, заполненный числами от <math>1</math> до <math>n</math>, показывающими, в какой кластер попал соответствующий объект.

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

Вычислительная мощность (соотношение времени выполнения и объема входных и выходных данных) для разных этапов:

<math>O(1)</math> для первого этапа

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

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

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

==Программная реализация алгоритма==
===Особенности реализации последовательного алгоритма===
===Локальность данных и вычислений===
===Возможные способы и особенности параллельной реализации алгоритма===
===Масштабируемость алгоритма и его реализации===
[[Файл:Chameleo.png|300px]]

На приведенном графике видна зависимость эффективности от объема данных и числа процессоров для реализации алгоритма, описанной в <ref name="real">http://research.ijcaonline.org/volume79/number8/pxc3891600.pdf</ref>

График построен для экспериментальной версии алгоритма для малого числа потоков.
Для тестирования использовался процессор Intel Pentium IV для одного потока, Intel Core i5 для 4-х потоков и Intel Core i7 для 8 потоков.

Для набора из 8000 точек запуск на 8 потоках даёт ускорение 4,46x по сравнению с запуском на 1 потоке.
Для набора из 10000 точек запуск на 8 процессорах даёт ускорение 4,8x по сравнению с запуском на 1 процессоре.
Для набора из 20000 точек запуск на 8 процессорах даёт ускорение 5x по сравнению с запуском на 1 процессоре.

Эффективность алгоритма падает при увеличении числа потоков (при увеличении числа потоков в 8 раз ускорение составляет ориентировочно 4-5x, то есть эффективность падает практически вдвое)

===Динамические характеристики и эффективность реализации алгоритма===
===Выводы для классов архитектур===
===Существующие реализации алгоритма===
Одна из последовательных реализаций алгоритма находится по ссылке [http://codeforge.com/article/192925]

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

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

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

2017-02-03T14:43:16Z

Hromovalexander:

{{assignment}}
Автор статьи: Хромов А. К.

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

=== Общее описание алгоритма ===
Алгоритм CHAMELEON - алгоритм динамической иерархической кластеризации графа.
<ref name="studo">http://studopedia.ru/7_41934_algoritm-dinamicheskoy-ierarhicheskoy-klasterizatsii-CHAMELEON.html</ref>
Кластеризация - разбиение графа на несколько подграфов таким образом, чтобы объекты внутри одного кластера были максимально близки (схожи), а данные двух различных кластеров максимально различались. Различие и схожесть объектов определяются некоей метрикой, известной заранее. Количество кластеров, на которые будет разбит граф, заранее неизвестно, и зависит от свойств объекта и выбранной метрики. Простейшей возможной метриков является расстояние между точками (если предполагать, что у каждой вершины графа есть координаты).

Алгоритм состоит из 3-х основных этапов:

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

2-й этап заключается в разбиении построенного графа на небольшие кластеры (связные подграфы)

3-й этап состоит в формировании итогового множества кластеров

=== Математическое описание алгоритма ===
'''Исходные данные'''

Множество из n объектов и заданные расстояния между объектами. Эта информация позволяет построить матрицу смежности, в которой будут указаны расстояния между соответствующими объектами по некой метрике. Матрица смежности симметрична, на главной диагонали стоят 0, поэтому достаточно хранить <math>\frac{n(n-1)}{2}</math> элементов. Кроме того задаются параметры, влияющие на работу алгоритма - число k, по которому на первом этапе строится граф по принципу k ближайших соседей, и два параметра <math>{T_{ri}}</math> и <math>{T_{rc}}</math>, используемые на третьем этапе для того, что определить, что не нужно далее продолжать кластеризацию.

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

На первом этапе строится граф <math>G(V,E)</math>, <math>V</math> - множество вершин, <math>E</math> - множество ребер, по принципу k ближайших соседей. Изначально граф состоит из множества вершин и пустого множества ребер. Для каждой вершины графа мы выбираем k других вершин, расстояния до которых минимальны (то есть k первых вершин в списке вершин графа, упорядоченных по увеличению расстояния до данной) и добавляем в множество ребер соответствующие ребра, соединяющие данную вершину с каждой из выбранных k вершин.

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

Состоит в итеративном разбиении графа на множество подграфов. Изначально (на первой итерации) разбиение состоит из единственного подграфа. Пусть <math>T</math> - множество подграфов на текущей итерации. Каждая итерация выполняется следующим образом - выбирается максимальный подграф из имеющихся в разбиении по числу вершин (то есть такой подграф <math>G_1(V_1,E_1)\in{T}: \forall {G_2(V_2,E_2)\in{T}: G_2\neq G_1} => |(V_1)|>|(V_2)|</math> ). Выбранный подграф разбивается на 2 подграфа следующим образом - сначала выбираются все разбиения <math>G_2(V_2,E_2)</math> и <math>G_3(V_3,E_3)</math>, такие, что <math>\min(|V_2|,|V_3|)\geq\frac{|V_1|}{4}</math>. Далее среди всех таких разбиений выбирается такое, для которого величина <math>\sum{|E_1^*|},E_1^* </math>- некое ребро, ведущее из вершины, попавшей в <math>G_2</math> в вершину, попавшую в <math>G_3</math>. В определенный момент, когда размер наибольшего кластера <math>|V_b|\leq{q*|V|}</math>, где <math>|V|</math> - количество вершин в изначальном графе, а <math>q</math> - предварительно заданный параметр, процесс дальнейшего разибения прекращается и алгоритм переходи на 3-й этап

'''Третий этап алгоритма:'''

Введем несколько определений:

Абсолютной взаимной связностью пары кластеров называется величина <math>EC_{({C_i},{C_j})}</math>, вычисляется как сумма весов ребер, соединяющих вершина 1-го кластера <math>C_i</math> с вершинами второго кластера <math>C_j</math>. Внутренняя связность кластера <math>E_{C_i}</math>вычисляется как сумма весов ребер, входящих в разделитель, разбивающих <math>C_i</math> на 2 равных подграфа.

Относительная взаимная связность пары кластеров <math>RI_{(C_i,C_j)}</math> вычисляется по формуле <math>RI_{(C_i,C_j)}=\frac{2*|EC_{(C_i,C_j)}|}{|EC_{C_i}|+|EC_{C_j}|}</math>

Абсолютное взаимное сходство пары кластеров <math>S_{E_{(C_i,C_j)}}</math>вычисляется как среднее сходство между связанными вершинами <math>C_i</math> и <math>C_j</math>

Относительное взаимное сходство пары кластеров <math>C_i</math> и <math>C_j</math> обозначается <math>RC_{(C_i,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_j|}{|C_i|+|C_j|}*S_{EC_{(C_j)}}}}</math>

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

Есть два различных подхода анализа сходства.

Первый - для каждой пары кластеров проверяется истинность следующих высказываний

<math>RI(Ci,Cj)\geq{T_{RI}} </math> и <math>RC_{(C_{i},C_{j})}\geq{T_{RC}}</math>

В случае, если для некоторого <math>C_i</math> существует несколько кластеров <math>C_j</math>, удовлетворяющих этим условиям, выбирается такой <math>C_j</math>, что

значение <math>EC_{(C_i,C_j)}</math> максимально.

Процесс останавливается, когда нет кластеров, удовлетворяющих указанным условиям (либо когда остался только 1 кластер)

Второй подход - выбирается такая пара кластеров, что <math>RI_{(C_i,C_j)}*RC^\alpha_{(C_i,C_j)}</math> максимально, где <math>\alpha</math> - заданный заранее параметр.

Процесс останавливается, когда нет кластеров, удовлетворяющих указанным условиям (либо когда остался только 1 кластер)
<ref name="chamel">http://www-users.cs.umn.edu/~han/dmclass/chameleon.pdf</ref>

=== Вычислительное ядро алгоритма ===
На первом этапе вычислительное ядро состоит из построения графа k ближайших соседей по исходной матрице смежности (требуется для каждой вершины перебрать всех соседей и выделить k ближайших)

На втором этапе вычислительное ядро состоит из повторяющегося нахождения разбиения графа на два подграфа, удовлетворяющего ранее описанным условиям

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

=== Макроструктура алгоритма ===
1. Построение графа k-ближайших соседей по исходным данным

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

3. Итеративно осуществляется обхединение подграфов, на основе метрик взаимной связности и взаимного сходства. Процесс объединения завершается в момент достижения целевых показателей по данным метрикам.

=== Схема реализации последовательного алгоритма ===
Схема представлена в виде C++-подобного псевдокода, макрооперации в алгоритме выделены в соответствии с предыдущим разделом описания.
int n; // Количество точек.
int k; // Параметр k
int Dist[n][n]; // Матрица расстояний между точками.

integer E[n][n]; // Матрица рёбер графа

foreach (int i=0; i<n; i++) ) {
integer KNeighbours[k]; // список, используемый для хранения ближайших соседей
integer countN = 0;

foreach (int j=i+1; j<n; j++ ) {
//Заполняем список k ближайших соседей по матрице Dist
}

foreach (int j=0; j<k; j++) {
E[i][KNeighbours[j]] = 1;
}
}
return E;

double q; //Параметр, описание находится в соответствующем разделе.
Graph g = getBiggestGraph(); //Находим граф максимального размера
int maxSize = getSize(g); //Находим размер данного графа
while (maxSize > n * q) {
breakGraph(g); // Разбиваем граф
}

Graph graphs[m]; //Разбиение по кластерам
while (count(graphs)>1){
pairs_exist = false //Значение будет обновлено позже, если найдется подходящая пара для объединения
for (int i = 0; i < m; i++) {
for (int j = i + 1; j < m; j++) {
if (checkSimilarity(graphs[i],graphs[j])) { //Проверяем, достаточно ли схожи графы для объединения
unite(graphs[i], graphs[l])
} else {
break;
}
}
}
}

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

На втором этапе для итеративного разбиения требуется <math>O(nm)</math>операций, где <math>n</math> - количество вершин графа, а <math>m</math> - количество подграфов в итоговом разбиении.

На третьем этапе требуется <math>O(m^2logm)</math> операций, причем вычисление метрики считается за одну операцию.

Итоговая оценка последовательной сложности <math>O(n^2)+O(nm)+O(m^2logm)</math>

=== Информационный граф ===
[[Файл:Инфограф.png]]

=== Ресурс параллелизма алгоритма ===
На первом этапе вычисление <math>k</math> ближайших вершин для <math>i</math>-й вершины можно распараллелить между <math>n</math> процессами (это вычисление независимо для каждой вершины).
На втором и третьем этапах процессы разбиения и объединения подграфов происходят последовательно.
Получаем оценку параллельной сложности алгоритма <math>O(nm)+O(m^2logm)</math>

=== Входные и выходные данные алгоритма ===
На вход алгоритму подается множество из <math>n</math> векторов длины <math>l</math>, описывающих объекты для кластеризации.
Также передаются параметры <math>k</math> (для построения графа k ближайших соседей на первом этапе) и <math>q</math> (используется на втором этапе для определения критерия прекращения итерационного процесса).
На выходе алгоритм выдает массив длины <math>n</math>, заполненный числами от <math>1</math> до <math>n</math>, показывающими, в какой кластер попал соответствующий объект.

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

Вычислительная мощность (соотношение времени выполнения и объема входных и выходных данных) для разных этапов:

<math>O(1)</math> для первого этапа

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

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

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

==Программная реализация алгоритма==
===Особенности реализации последовательного алгоритма===
===Локальность данных и вычислений===
===Возможные способы и особенности параллельной реализации алгоритма===
===Масштабируемость алгоритма и его реализации===
[[Файл:Chameleo.png|300px]]

На приведенном графике видна зависимость эффективности от объема данных и числа процессоров для реализации алгоритма, описанной в <ref name="real">http://research.ijcaonline.org/volume79/number8/pxc3891600.pdf</ref>

График построен для экспериментальной версии алгоритма для малого числа потоков.
Для тестирования использовался процессор Intel Pentium IV для одного потока, Intel Core i5 для 4-х потоков и Intel Core i7 для 8 потоков.

К сожалению, в исследовании, на основе которого строится данный график, не приведены более подробные данные о том, как именно запускались тесты. Приводится только информация о процессорах, на которых выполнялись вычисления. Также в исследовании не приведён запускавшийся код. Вместе с тем, данное исследование является единственным, опирающимся на параллельный код и приводящее результаты запуска данного кода. Других параллельных реализаций найдено не было.

Для набора из 8000 точек запуск на 8 потоках даёт ускорение 4,46x по сравнению с запуском на 1 потоке.
Для набора из 10000 точек запуск на 8 процессорах даёт ускорение 4,8x по сравнению с запуском на 1 процессоре.
Для набора из 20000 точек запуск на 8 процессорах даёт ускорение 5x по сравнению с запуском на 1 процессоре.

Эффективность алгоритма падает при увеличении числа потоков (при увеличении числа потоков в 8 раз ускорение составляет ориентировочно 4-5x, то есть эффективность падает практически вдвое)

===Динамические характеристики и эффективность реализации алгоритма===
===Выводы для классов архитектур===
===Существующие реализации алгоритма===
Одна из последовательных реализаций алгоритма находится по ссылке [http://codeforge.com/article/192925]

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

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

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

2017-02-03T14:43:10Z

Hromovalexander:

{{assignment}
Автор статьи: Хромов А. К.

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

=== Общее описание алгоритма ===
Алгоритм CHAMELEON - алгоритм динамической иерархической кластеризации графа.
<ref name="studo">http://studopedia.ru/7_41934_algoritm-dinamicheskoy-ierarhicheskoy-klasterizatsii-CHAMELEON.html</ref>
Кластеризация - разбиение графа на несколько подграфов таким образом, чтобы объекты внутри одного кластера были максимально близки (схожи), а данные двух различных кластеров максимально различались. Различие и схожесть объектов определяются некоей метрикой, известной заранее. Количество кластеров, на которые будет разбит граф, заранее неизвестно, и зависит от свойств объекта и выбранной метрики. Простейшей возможной метриков является расстояние между точками (если предполагать, что у каждой вершины графа есть координаты).

Алгоритм состоит из 3-х основных этапов:

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

2-й этап заключается в разбиении построенного графа на небольшие кластеры (связные подграфы)

3-й этап состоит в формировании итогового множества кластеров

=== Математическое описание алгоритма ===
'''Исходные данные'''

Множество из n объектов и заданные расстояния между объектами. Эта информация позволяет построить матрицу смежности, в которой будут указаны расстояния между соответствующими объектами по некой метрике. Матрица смежности симметрична, на главной диагонали стоят 0, поэтому достаточно хранить <math>\frac{n(n-1)}{2}</math> элементов. Кроме того задаются параметры, влияющие на работу алгоритма - число k, по которому на первом этапе строится граф по принципу k ближайших соседей, и два параметра <math>{T_{ri}}</math> и <math>{T_{rc}}</math>, используемые на третьем этапе для того, что определить, что не нужно далее продолжать кластеризацию.

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

На первом этапе строится граф <math>G(V,E)</math>, <math>V</math> - множество вершин, <math>E</math> - множество ребер, по принципу k ближайших соседей. Изначально граф состоит из множества вершин и пустого множества ребер. Для каждой вершины графа мы выбираем k других вершин, расстояния до которых минимальны (то есть k первых вершин в списке вершин графа, упорядоченных по увеличению расстояния до данной) и добавляем в множество ребер соответствующие ребра, соединяющие данную вершину с каждой из выбранных k вершин.

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

Состоит в итеративном разбиении графа на множество подграфов. Изначально (на первой итерации) разбиение состоит из единственного подграфа. Пусть <math>T</math> - множество подграфов на текущей итерации. Каждая итерация выполняется следующим образом - выбирается максимальный подграф из имеющихся в разбиении по числу вершин (то есть такой подграф <math>G_1(V_1,E_1)\in{T}: \forall {G_2(V_2,E_2)\in{T}: G_2\neq G_1} => |(V_1)|>|(V_2)|</math> ). Выбранный подграф разбивается на 2 подграфа следующим образом - сначала выбираются все разбиения <math>G_2(V_2,E_2)</math> и <math>G_3(V_3,E_3)</math>, такие, что <math>\min(|V_2|,|V_3|)\geq\frac{|V_1|}{4}</math>. Далее среди всех таких разбиений выбирается такое, для которого величина <math>\sum{|E_1^*|},E_1^* </math>- некое ребро, ведущее из вершины, попавшей в <math>G_2</math> в вершину, попавшую в <math>G_3</math>. В определенный момент, когда размер наибольшего кластера <math>|V_b|\leq{q*|V|}</math>, где <math>|V|</math> - количество вершин в изначальном графе, а <math>q</math> - предварительно заданный параметр, процесс дальнейшего разибения прекращается и алгоритм переходи на 3-й этап

'''Третий этап алгоритма:'''

Введем несколько определений:

Абсолютной взаимной связностью пары кластеров называется величина <math>EC_{({C_i},{C_j})}</math>, вычисляется как сумма весов ребер, соединяющих вершина 1-го кластера <math>C_i</math> с вершинами второго кластера <math>C_j</math>. Внутренняя связность кластера <math>E_{C_i}</math>вычисляется как сумма весов ребер, входящих в разделитель, разбивающих <math>C_i</math> на 2 равных подграфа.

Относительная взаимная связность пары кластеров <math>RI_{(C_i,C_j)}</math> вычисляется по формуле <math>RI_{(C_i,C_j)}=\frac{2*|EC_{(C_i,C_j)}|}{|EC_{C_i}|+|EC_{C_j}|}</math>

Абсолютное взаимное сходство пары кластеров <math>S_{E_{(C_i,C_j)}}</math>вычисляется как среднее сходство между связанными вершинами <math>C_i</math> и <math>C_j</math>

Относительное взаимное сходство пары кластеров <math>C_i</math> и <math>C_j</math> обозначается <math>RC_{(C_i,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_j|}{|C_i|+|C_j|}*S_{EC_{(C_j)}}}}</math>

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

Есть два различных подхода анализа сходства.

Первый - для каждой пары кластеров проверяется истинность следующих высказываний

<math>RI(Ci,Cj)\geq{T_{RI}} </math> и <math>RC_{(C_{i},C_{j})}\geq{T_{RC}}</math>

В случае, если для некоторого <math>C_i</math> существует несколько кластеров <math>C_j</math>, удовлетворяющих этим условиям, выбирается такой <math>C_j</math>, что

значение <math>EC_{(C_i,C_j)}</math> максимально.

Процесс останавливается, когда нет кластеров, удовлетворяющих указанным условиям (либо когда остался только 1 кластер)

Второй подход - выбирается такая пара кластеров, что <math>RI_{(C_i,C_j)}*RC^\alpha_{(C_i,C_j)}</math> максимально, где <math>\alpha</math> - заданный заранее параметр.

Процесс останавливается, когда нет кластеров, удовлетворяющих указанным условиям (либо когда остался только 1 кластер)
<ref name="chamel">http://www-users.cs.umn.edu/~han/dmclass/chameleon.pdf</ref>

=== Вычислительное ядро алгоритма ===
На первом этапе вычислительное ядро состоит из построения графа k ближайших соседей по исходной матрице смежности (требуется для каждой вершины перебрать всех соседей и выделить k ближайших)

На втором этапе вычислительное ядро состоит из повторяющегося нахождения разбиения графа на два подграфа, удовлетворяющего ранее описанным условиям

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

=== Макроструктура алгоритма ===
1. Построение графа k-ближайших соседей по исходным данным

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

3. Итеративно осуществляется обхединение подграфов, на основе метрик взаимной связности и взаимного сходства. Процесс объединения завершается в момент достижения целевых показателей по данным метрикам.

=== Схема реализации последовательного алгоритма ===
Схема представлена в виде C++-подобного псевдокода, макрооперации в алгоритме выделены в соответствии с предыдущим разделом описания.
int n; // Количество точек.
int k; // Параметр k
int Dist[n][n]; // Матрица расстояний между точками.

integer E[n][n]; // Матрица рёбер графа

foreach (int i=0; i<n; i++) ) {
integer KNeighbours[k]; // список, используемый для хранения ближайших соседей
integer countN = 0;

foreach (int j=i+1; j<n; j++ ) {
//Заполняем список k ближайших соседей по матрице Dist
}

foreach (int j=0; j<k; j++) {
E[i][KNeighbours[j]] = 1;
}
}
return E;

double q; //Параметр, описание находится в соответствующем разделе.
Graph g = getBiggestGraph(); //Находим граф максимального размера
int maxSize = getSize(g); //Находим размер данного графа
while (maxSize > n * q) {
breakGraph(g); // Разбиваем граф
}

Graph graphs[m]; //Разбиение по кластерам
while (count(graphs)>1){
pairs_exist = false //Значение будет обновлено позже, если найдется подходящая пара для объединения
for (int i = 0; i < m; i++) {
for (int j = i + 1; j < m; j++) {
if (checkSimilarity(graphs[i],graphs[j])) { //Проверяем, достаточно ли схожи графы для объединения
unite(graphs[i], graphs[l])
} else {
break;
}
}
}
}

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

На втором этапе для итеративного разбиения требуется <math>O(nm)</math>операций, где <math>n</math> - количество вершин графа, а <math>m</math> - количество подграфов в итоговом разбиении.

На третьем этапе требуется <math>O(m^2logm)</math> операций, причем вычисление метрики считается за одну операцию.

Итоговая оценка последовательной сложности <math>O(n^2)+O(nm)+O(m^2logm)</math>

=== Информационный граф ===
[[Файл:Инфограф.png]]

=== Ресурс параллелизма алгоритма ===
На первом этапе вычисление <math>k</math> ближайших вершин для <math>i</math>-й вершины можно распараллелить между <math>n</math> процессами (это вычисление независимо для каждой вершины).
На втором и третьем этапах процессы разбиения и объединения подграфов происходят последовательно.
Получаем оценку параллельной сложности алгоритма <math>O(nm)+O(m^2logm)</math>

=== Входные и выходные данные алгоритма ===
На вход алгоритму подается множество из <math>n</math> векторов длины <math>l</math>, описывающих объекты для кластеризации.
Также передаются параметры <math>k</math> (для построения графа k ближайших соседей на первом этапе) и <math>q</math> (используется на втором этапе для определения критерия прекращения итерационного процесса).
На выходе алгоритм выдает массив длины <math>n</math>, заполненный числами от <math>1</math> до <math>n</math>, показывающими, в какой кластер попал соответствующий объект.

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

Вычислительная мощность (соотношение времени выполнения и объема входных и выходных данных) для разных этапов:

<math>O(1)</math> для первого этапа

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

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

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

==Программная реализация алгоритма==
===Особенности реализации последовательного алгоритма===
===Локальность данных и вычислений===
===Возможные способы и особенности параллельной реализации алгоритма===
===Масштабируемость алгоритма и его реализации===
[[Файл:Chameleo.png|300px]]

На приведенном графике видна зависимость эффективности от объема данных и числа процессоров для реализации алгоритма, описанной в <ref name="real">http://research.ijcaonline.org/volume79/number8/pxc3891600.pdf</ref>

График построен для экспериментальной версии алгоритма для малого числа потоков.
Для тестирования использовался процессор Intel Pentium IV для одного потока, Intel Core i5 для 4-х потоков и Intel Core i7 для 8 потоков.

К сожалению, в исследовании, на основе которого строится данный график, не приведены более подробные данные о том, как именно запускались тесты. Приводится только информация о процессорах, на которых выполнялись вычисления. Также в исследовании не приведён запускавшийся код. Вместе с тем, данное исследование является единственным, опирающимся на параллельный код и приводящее результаты запуска данного кода. Других параллельных реализаций найдено не было.

Для набора из 8000 точек запуск на 8 потоках даёт ускорение 4,46x по сравнению с запуском на 1 потоке.
Для набора из 10000 точек запуск на 8 процессорах даёт ускорение 4,8x по сравнению с запуском на 1 процессоре.
Для набора из 20000 точек запуск на 8 процессорах даёт ускорение 5x по сравнению с запуском на 1 процессоре.

Эффективность алгоритма падает при увеличении числа потоков (при увеличении числа потоков в 8 раз ускорение составляет ориентировочно 4-5x, то есть эффективность падает практически вдвое)

===Динамические характеристики и эффективность реализации алгоритма===
===Выводы для классов архитектур===
===Существующие реализации алгоритма===
Одна из последовательных реализаций алгоритма находится по ссылке [http://codeforge.com/article/192925]

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

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

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

2017-02-03T14:42:02Z

Hromovalexander:

{assigned}
Автор статьи: Хромов А. К.

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

=== Общее описание алгоритма ===
Алгоритм CHAMELEON - алгоритм динамической иерархической кластеризации графа.
<ref name="studo">http://studopedia.ru/7_41934_algoritm-dinamicheskoy-ierarhicheskoy-klasterizatsii-CHAMELEON.html</ref>
Кластеризация - разбиение графа на несколько подграфов таким образом, чтобы объекты внутри одного кластера были максимально близки (схожи), а данные двух различных кластеров максимально различались. Различие и схожесть объектов определяются некоей метрикой, известной заранее. Количество кластеров, на которые будет разбит граф, заранее неизвестно, и зависит от свойств объекта и выбранной метрики. Простейшей возможной метриков является расстояние между точками (если предполагать, что у каждой вершины графа есть координаты).

Алгоритм состоит из 3-х основных этапов:

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

2-й этап заключается в разбиении построенного графа на небольшие кластеры (связные подграфы)

3-й этап состоит в формировании итогового множества кластеров

=== Математическое описание алгоритма ===
'''Исходные данные'''

Множество из n объектов и заданные расстояния между объектами. Эта информация позволяет построить матрицу смежности, в которой будут указаны расстояния между соответствующими объектами по некой метрике. Матрица смежности симметрична, на главной диагонали стоят 0, поэтому достаточно хранить <math>\frac{n(n-1)}{2}</math> элементов. Кроме того задаются параметры, влияющие на работу алгоритма - число k, по которому на первом этапе строится граф по принципу k ближайших соседей, и два параметра <math>{T_{ri}}</math> и <math>{T_{rc}}</math>, используемые на третьем этапе для того, что определить, что не нужно далее продолжать кластеризацию.

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

На первом этапе строится граф <math>G(V,E)</math>, <math>V</math> - множество вершин, <math>E</math> - множество ребер, по принципу k ближайших соседей. Изначально граф состоит из множества вершин и пустого множества ребер. Для каждой вершины графа мы выбираем k других вершин, расстояния до которых минимальны (то есть k первых вершин в списке вершин графа, упорядоченных по увеличению расстояния до данной) и добавляем в множество ребер соответствующие ребра, соединяющие данную вершину с каждой из выбранных k вершин.

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

Состоит в итеративном разбиении графа на множество подграфов. Изначально (на первой итерации) разбиение состоит из единственного подграфа. Пусть <math>T</math> - множество подграфов на текущей итерации. Каждая итерация выполняется следующим образом - выбирается максимальный подграф из имеющихся в разбиении по числу вершин (то есть такой подграф <math>G_1(V_1,E_1)\in{T}: \forall {G_2(V_2,E_2)\in{T}: G_2\neq G_1} => |(V_1)|>|(V_2)|</math> ). Выбранный подграф разбивается на 2 подграфа следующим образом - сначала выбираются все разбиения <math>G_2(V_2,E_2)</math> и <math>G_3(V_3,E_3)</math>, такие, что <math>\min(|V_2|,|V_3|)\geq\frac{|V_1|}{4}</math>. Далее среди всех таких разбиений выбирается такое, для которого величина <math>\sum{|E_1^*|},E_1^* </math>- некое ребро, ведущее из вершины, попавшей в <math>G_2</math> в вершину, попавшую в <math>G_3</math>. В определенный момент, когда размер наибольшего кластера <math>|V_b|\leq{q*|V|}</math>, где <math>|V|</math> - количество вершин в изначальном графе, а <math>q</math> - предварительно заданный параметр, процесс дальнейшего разибения прекращается и алгоритм переходи на 3-й этап

'''Третий этап алгоритма:'''

Введем несколько определений:

Абсолютной взаимной связностью пары кластеров называется величина <math>EC_{({C_i},{C_j})}</math>, вычисляется как сумма весов ребер, соединяющих вершина 1-го кластера <math>C_i</math> с вершинами второго кластера <math>C_j</math>. Внутренняя связность кластера <math>E_{C_i}</math>вычисляется как сумма весов ребер, входящих в разделитель, разбивающих <math>C_i</math> на 2 равных подграфа.

Относительная взаимная связность пары кластеров <math>RI_{(C_i,C_j)}</math> вычисляется по формуле <math>RI_{(C_i,C_j)}=\frac{2*|EC_{(C_i,C_j)}|}{|EC_{C_i}|+|EC_{C_j}|}</math>

Абсолютное взаимное сходство пары кластеров <math>S_{E_{(C_i,C_j)}}</math>вычисляется как среднее сходство между связанными вершинами <math>C_i</math> и <math>C_j</math>

Относительное взаимное сходство пары кластеров <math>C_i</math> и <math>C_j</math> обозначается <math>RC_{(C_i,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_j|}{|C_i|+|C_j|}*S_{EC_{(C_j)}}}}</math>

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

Есть два различных подхода анализа сходства.

Первый - для каждой пары кластеров проверяется истинность следующих высказываний

<math>RI(Ci,Cj)\geq{T_{RI}} </math> и <math>RC_{(C_{i},C_{j})}\geq{T_{RC}}</math>

В случае, если для некоторого <math>C_i</math> существует несколько кластеров <math>C_j</math>, удовлетворяющих этим условиям, выбирается такой <math>C_j</math>, что

значение <math>EC_{(C_i,C_j)}</math> максимально.

Процесс останавливается, когда нет кластеров, удовлетворяющих указанным условиям (либо когда остался только 1 кластер)

Второй подход - выбирается такая пара кластеров, что <math>RI_{(C_i,C_j)}*RC^\alpha_{(C_i,C_j)}</math> максимально, где <math>\alpha</math> - заданный заранее параметр.

Процесс останавливается, когда нет кластеров, удовлетворяющих указанным условиям (либо когда остался только 1 кластер)
<ref name="chamel">http://www-users.cs.umn.edu/~han/dmclass/chameleon.pdf</ref>

=== Вычислительное ядро алгоритма ===
На первом этапе вычислительное ядро состоит из построения графа k ближайших соседей по исходной матрице смежности (требуется для каждой вершины перебрать всех соседей и выделить k ближайших)

На втором этапе вычислительное ядро состоит из повторяющегося нахождения разбиения графа на два подграфа, удовлетворяющего ранее описанным условиям

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

=== Макроструктура алгоритма ===
1. Построение графа k-ближайших соседей по исходным данным

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

3. Итеративно осуществляется обхединение подграфов, на основе метрик взаимной связности и взаимного сходства. Процесс объединения завершается в момент достижения целевых показателей по данным метрикам.

=== Схема реализации последовательного алгоритма ===
Схема представлена в виде C++-подобного псевдокода, макрооперации в алгоритме выделены в соответствии с предыдущим разделом описания.
int n; // Количество точек.
int k; // Параметр k
int Dist[n][n]; // Матрица расстояний между точками.

integer E[n][n]; // Матрица рёбер графа

foreach (int i=0; i<n; i++) ) {
integer KNeighbours[k]; // список, используемый для хранения ближайших соседей
integer countN = 0;

foreach (int j=i+1; j<n; j++ ) {
//Заполняем список k ближайших соседей по матрице Dist
}

foreach (int j=0; j<k; j++) {
E[i][KNeighbours[j]] = 1;
}
}
return E;

double q; //Параметр, описание находится в соответствующем разделе.
Graph g = getBiggestGraph(); //Находим граф максимального размера
int maxSize = getSize(g); //Находим размер данного графа
while (maxSize > n * q) {
breakGraph(g); // Разбиваем граф
}

Graph graphs[m]; //Разбиение по кластерам
while (count(graphs)>1){
pairs_exist = false //Значение будет обновлено позже, если найдется подходящая пара для объединения
for (int i = 0; i < m; i++) {
for (int j = i + 1; j < m; j++) {
if (checkSimilarity(graphs[i],graphs[j])) { //Проверяем, достаточно ли схожи графы для объединения
unite(graphs[i], graphs[l])
} else {
break;
}
}
}
}

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

На втором этапе для итеративного разбиения требуется <math>O(nm)</math>операций, где <math>n</math> - количество вершин графа, а <math>m</math> - количество подграфов в итоговом разбиении.

На третьем этапе требуется <math>O(m^2logm)</math> операций, причем вычисление метрики считается за одну операцию.

Итоговая оценка последовательной сложности <math>O(n^2)+O(nm)+O(m^2logm)</math>

=== Информационный граф ===
[[Файл:Инфограф.png]]

=== Ресурс параллелизма алгоритма ===
На первом этапе вычисление <math>k</math> ближайших вершин для <math>i</math>-й вершины можно распараллелить между <math>n</math> процессами (это вычисление независимо для каждой вершины).
На втором и третьем этапах процессы разбиения и объединения подграфов происходят последовательно.
Получаем оценку параллельной сложности алгоритма <math>O(nm)+O(m^2logm)</math>

=== Входные и выходные данные алгоритма ===
На вход алгоритму подается множество из <math>n</math> векторов длины <math>l</math>, описывающих объекты для кластеризации.
Также передаются параметры <math>k</math> (для построения графа k ближайших соседей на первом этапе) и <math>q</math> (используется на втором этапе для определения критерия прекращения итерационного процесса).
На выходе алгоритм выдает массив длины <math>n</math>, заполненный числами от <math>1</math> до <math>n</math>, показывающими, в какой кластер попал соответствующий объект.

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

Вычислительная мощность (соотношение времени выполнения и объема входных и выходных данных) для разных этапов:

<math>O(1)</math> для первого этапа

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

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

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

==Программная реализация алгоритма==
===Особенности реализации последовательного алгоритма===
===Локальность данных и вычислений===
===Возможные способы и особенности параллельной реализации алгоритма===
===Масштабируемость алгоритма и его реализации===
[[Файл:Chameleo.png|300px]]

На приведенном графике видна зависимость эффективности от объема данных и числа процессоров для реализации алгоритма, описанной в <ref name="real">http://research.ijcaonline.org/volume79/number8/pxc3891600.pdf</ref>

График построен для экспериментальной версии алгоритма для малого числа потоков.
Для тестирования использовался процессор Intel Pentium IV для одного потока, Intel Core i5 для 4-х потоков и Intel Core i7 для 8 потоков.

К сожалению, в исследовании, на основе которого строится данный график, не приведены более подробные данные о том, как именно запускались тесты. Приводится только информация о процессорах, на которых выполнялись вычисления. Также в исследовании не приведён запускавшийся код. Вместе с тем, данное исследование является единственным, опирающимся на параллельный код и приводящее результаты запуска данного кода. Других параллельных реализаций найдено не было.

Для набора из 8000 точек запуск на 8 потоках даёт ускорение 4,46x по сравнению с запуском на 1 потоке.
Для набора из 10000 точек запуск на 8 процессорах даёт ускорение 4,8x по сравнению с запуском на 1 процессоре.
Для набора из 20000 точек запуск на 8 процессорах даёт ускорение 5x по сравнению с запуском на 1 процессоре.

Эффективность алгоритма падает при увеличении числа потоков (при увеличении числа потоков в 8 раз ускорение составляет ориентировочно 4-5x, то есть эффективность падает практически вдвое)

===Динамические характеристики и эффективность реализации алгоритма===
===Выводы для классов архитектур===
===Существующие реализации алгоритма===
Одна из последовательных реализаций алгоритма находится по ссылке [http://codeforge.com/article/192925]

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

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

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

2017-02-03T14:41:20Z

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

Автор статьи: Хромов А. К.

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

=== Общее описание алгоритма ===
Алгоритм CHAMELEON - алгоритм динамической иерархической кластеризации графа.
<ref name="studo">http://studopedia.ru/7_41934_algoritm-dinamicheskoy-ierarhicheskoy-klasterizatsii-CHAMELEON.html</ref>
Кластеризация - разбиение графа на несколько подграфов таким образом, чтобы объекты внутри одного кластера были максимально близки (схожи), а данные двух различных кластеров максимально различались. Различие и схожесть объектов определяются некоей метрикой, известной заранее. Количество кластеров, на которые будет разбит граф, заранее неизвестно, и зависит от свойств объекта и выбранной метрики. Простейшей возможной метриков является расстояние между точками (если предполагать, что у каждой вершины графа есть координаты).

Алгоритм состоит из 3-х основных этапов:

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

2-й этап заключается в разбиении построенного графа на небольшие кластеры (связные подграфы)

3-й этап состоит в формировании итогового множества кластеров

=== Математическое описание алгоритма ===
'''Исходные данные'''

Множество из n объектов и заданные расстояния между объектами. Эта информация позволяет построить матрицу смежности, в которой будут указаны расстояния между соответствующими объектами по некой метрике. Матрица смежности симметрична, на главной диагонали стоят 0, поэтому достаточно хранить <math>\frac{n(n-1)}{2}</math> элементов. Кроме того задаются параметры, влияющие на работу алгоритма - число k, по которому на первом этапе строится граф по принципу k ближайших соседей, и два параметра <math>{T_{ri}}</math> и <math>{T_{rc}}</math>, используемые на третьем этапе для того, что определить, что не нужно далее продолжать кластеризацию.

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

На первом этапе строится граф <math>G(V,E)</math>, <math>V</math> - множество вершин, <math>E</math> - множество ребер, по принципу k ближайших соседей. Изначально граф состоит из множества вершин и пустого множества ребер. Для каждой вершины графа мы выбираем k других вершин, расстояния до которых минимальны (то есть k первых вершин в списке вершин графа, упорядоченных по увеличению расстояния до данной) и добавляем в множество ребер соответствующие ребра, соединяющие данную вершину с каждой из выбранных k вершин.

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

Состоит в итеративном разбиении графа на множество подграфов. Изначально (на первой итерации) разбиение состоит из единственного подграфа. Пусть <math>T</math> - множество подграфов на текущей итерации. Каждая итерация выполняется следующим образом - выбирается максимальный подграф из имеющихся в разбиении по числу вершин (то есть такой подграф <math>G_1(V_1,E_1)\in{T}: \forall {G_2(V_2,E_2)\in{T}: G_2\neq G_1} => |(V_1)|>|(V_2)|</math> ). Выбранный подграф разбивается на 2 подграфа следующим образом - сначала выбираются все разбиения <math>G_2(V_2,E_2)</math> и <math>G_3(V_3,E_3)</math>, такие, что <math>\min(|V_2|,|V_3|)\geq\frac{|V_1|}{4}</math>. Далее среди всех таких разбиений выбирается такое, для которого величина <math>\sum{|E_1^*|},E_1^* </math>- некое ребро, ведущее из вершины, попавшей в <math>G_2</math> в вершину, попавшую в <math>G_3</math>. В определенный момент, когда размер наибольшего кластера <math>|V_b|\leq{q*|V|}</math>, где <math>|V|</math> - количество вершин в изначальном графе, а <math>q</math> - предварительно заданный параметр, процесс дальнейшего разибения прекращается и алгоритм переходи на 3-й этап

'''Третий этап алгоритма:'''

Введем несколько определений:

Абсолютной взаимной связностью пары кластеров называется величина <math>EC_{({C_i},{C_j})}</math>, вычисляется как сумма весов ребер, соединяющих вершина 1-го кластера <math>C_i</math> с вершинами второго кластера <math>C_j</math>. Внутренняя связность кластера <math>E_{C_i}</math>вычисляется как сумма весов ребер, входящих в разделитель, разбивающих <math>C_i</math> на 2 равных подграфа.

Относительная взаимная связность пары кластеров <math>RI_{(C_i,C_j)}</math> вычисляется по формуле <math>RI_{(C_i,C_j)}=\frac{2*|EC_{(C_i,C_j)}|}{|EC_{C_i}|+|EC_{C_j}|}</math>

Абсолютное взаимное сходство пары кластеров <math>S_{E_{(C_i,C_j)}}</math>вычисляется как среднее сходство между связанными вершинами <math>C_i</math> и <math>C_j</math>

Относительное взаимное сходство пары кластеров <math>C_i</math> и <math>C_j</math> обозначается <math>RC_{(C_i,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_j|}{|C_i|+|C_j|}*S_{EC_{(C_j)}}}}</math>

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

Есть два различных подхода анализа сходства.

Первый - для каждой пары кластеров проверяется истинность следующих высказываний

<math>RI(Ci,Cj)\geq{T_{RI}} </math> и <math>RC_{(C_{i},C_{j})}\geq{T_{RC}}</math>

В случае, если для некоторого <math>C_i</math> существует несколько кластеров <math>C_j</math>, удовлетворяющих этим условиям, выбирается такой <math>C_j</math>, что

значение <math>EC_{(C_i,C_j)}</math> максимально.

Процесс останавливается, когда нет кластеров, удовлетворяющих указанным условиям (либо когда остался только 1 кластер)

Второй подход - выбирается такая пара кластеров, что <math>RI_{(C_i,C_j)}*RC^\alpha_{(C_i,C_j)}</math> максимально, где <math>\alpha</math> - заданный заранее параметр.

Процесс останавливается, когда нет кластеров, удовлетворяющих указанным условиям (либо когда остался только 1 кластер)
<ref name="chamel">http://www-users.cs.umn.edu/~han/dmclass/chameleon.pdf</ref>

=== Вычислительное ядро алгоритма ===
На первом этапе вычислительное ядро состоит из построения графа k ближайших соседей по исходной матрице смежности (требуется для каждой вершины перебрать всех соседей и выделить k ближайших)

На втором этапе вычислительное ядро состоит из повторяющегося нахождения разбиения графа на два подграфа, удовлетворяющего ранее описанным условиям

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

=== Макроструктура алгоритма ===
1. Построение графа k-ближайших соседей по исходным данным

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

3. Итеративно осуществляется обхединение подграфов, на основе метрик взаимной связности и взаимного сходства. Процесс объединения завершается в момент достижения целевых показателей по данным метрикам.

=== Схема реализации последовательного алгоритма ===
Схема представлена в виде C++-подобного псевдокода, макрооперации в алгоритме выделены в соответствии с предыдущим разделом описания.
int n; // Количество точек.
int k; // Параметр k
int Dist[n][n]; // Матрица расстояний между точками.

integer E[n][n]; // Матрица рёбер графа

foreach (int i=0; i<n; i++) ) {
integer KNeighbours[k]; // список, используемый для хранения ближайших соседей
integer countN = 0;

foreach (int j=i+1; j<n; j++ ) {
//Заполняем список k ближайших соседей по матрице Dist
}

foreach (int j=0; j<k; j++) {
E[i][KNeighbours[j]] = 1;
}
}
return E;

double q; //Параметр, описание находится в соответствующем разделе.
Graph g = getBiggestGraph(); //Находим граф максимального размера
int maxSize = getSize(g); //Находим размер данного графа
while (maxSize > n * q) {
breakGraph(g); // Разбиваем граф
}

Graph graphs[m]; //Разбиение по кластерам
while (count(graphs)>1){
pairs_exist = false //Значение будет обновлено позже, если найдется подходящая пара для объединения
for (int i = 0; i < m; i++) {
for (int j = i + 1; j < m; j++) {
if (checkSimilarity(graphs[i],graphs[j])) { //Проверяем, достаточно ли схожи графы для объединения
unite(graphs[i], graphs[l])
} else {
break;
}
}
}
}

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

На втором этапе для итеративного разбиения требуется <math>O(nm)</math>операций, где <math>n</math> - количество вершин графа, а <math>m</math> - количество подграфов в итоговом разбиении.

На третьем этапе требуется <math>O(m^2logm)</math> операций, причем вычисление метрики считается за одну операцию.

Итоговая оценка последовательной сложности <math>O(n^2)+O(nm)+O(m^2logm)</math>

=== Информационный граф ===
[[Файл:Инфограф.png]]

=== Ресурс параллелизма алгоритма ===
На первом этапе вычисление <math>k</math> ближайших вершин для <math>i</math>-й вершины можно распараллелить между <math>n</math> процессами (это вычисление независимо для каждой вершины).
На втором и третьем этапах процессы разбиения и объединения подграфов происходят последовательно.
Получаем оценку параллельной сложности алгоритма <math>O(nm)+O(m^2logm)</math>

=== Входные и выходные данные алгоритма ===
На вход алгоритму подается множество из <math>n</math> векторов длины <math>l</math>, описывающих объекты для кластеризации.
Также передаются параметры <math>k</math> (для построения графа k ближайших соседей на первом этапе) и <math>q</math> (используется на втором этапе для определения критерия прекращения итерационного процесса).
На выходе алгоритм выдает массив длины <math>n</math>, заполненный числами от <math>1</math> до <math>n</math>, показывающими, в какой кластер попал соответствующий объект.

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

Вычислительная мощность (соотношение времени выполнения и объема входных и выходных данных) для разных этапов:

<math>O(1)</math> для первого этапа

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

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

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

==Программная реализация алгоритма==
===Особенности реализации последовательного алгоритма===
===Локальность данных и вычислений===
===Возможные способы и особенности параллельной реализации алгоритма===
===Масштабируемость алгоритма и его реализации===
[[Файл:Chameleo.png|300px]]

На приведенном графике видна зависимость эффективности от объема данных и числа процессоров для реализации алгоритма, описанной в <ref name="real">http://research.ijcaonline.org/volume79/number8/pxc3891600.pdf</ref>

График построен для экспериментальной версии алгоритма для малого числа потоков.
Для тестирования использовался процессор Intel Pentium IV для одного потока, Intel Core i5 для 4-х потоков и Intel Core i7 для 8 потоков.

К сожалению, в исследовании, на основе которого строится данный график, не приведены более подробные данные о том, как именно запускались тесты. Приводится только информация о процессорах, на которых выполнялись вычисления. Также в исследовании не приведён запускавшийся код. Вместе с тем, данное исследование является единственным, опирающимся на параллельный код и приводящее результаты запуска данного кода. Других параллельных реализаций найдено не было.

Для набора из 8000 точек запуск на 8 потоках даёт ускорение 4,46x по сравнению с запуском на 1 потоке.
Для набора из 10000 точек запуск на 8 процессорах даёт ускорение 4,8x по сравнению с запуском на 1 процессоре.
Для набора из 20000 точек запуск на 8 процессорах даёт ускорение 5x по сравнению с запуском на 1 процессоре.

Эффективность алгоритма падает при увеличении числа потоков (при увеличении числа потоков в 8 раз ускорение составляет ориентировочно 4-5x, то есть эффективность падает практически вдвое)

===Динамические характеристики и эффективность реализации алгоритма===
===Выводы для классов архитектур===
===Существующие реализации алгоритма===
Одна из последовательных реализаций алгоритма находится по ссылке [http://codeforge.com/article/192925]

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

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

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

2017-02-03T13:53:04Z

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

Автор статьи: Хромов А. К.

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

=== Общее описание алгоритма ===
Алгоритм CHAMELEON - алгоритм динамической иерархической кластеризации графа.
<ref name="studo">http://studopedia.ru/7_41934_algoritm-dinamicheskoy-ierarhicheskoy-klasterizatsii-CHAMELEON.html</ref>
Кластеризация - разбиение графа на несколько подграфов таким образом, чтобы объекты внутри одного кластера были максимально близки (схожи), а данные двух различных кластеров максимально различались. Различие и схожесть объектов определяются некоей метрикой, известной заранее. Количество кластеров, на которые будет разбит граф, заранее неизвестно, и зависит от свойств объекта и выбранной метрики. Простейшей возможной метриков является расстояние между точками (если предполагать, что у каждой вершины графа есть координаты).

Алгоритм состоит из 3-х основных этапов:

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

2-й этап заключается в разбиении построенного графа на небольшие кластеры (связные подграфы)

3-й этап состоит в формировании итогового множества кластеров

=== Математическое описание алгоритма ===
'''Исходные данные'''

Множество из n объектов и заданные расстояния между объектами. Эта информация позволяет построить матрицу смежности, в которой будут указаны расстояния между соответствующими объектами по некой метрике. Матрица смежности симметрична, на главной диагонали стоят 0, поэтому достаточно хранить <math>\frac{n(n-1)}{2}</math> элементов. Кроме того задаются параметры, влияющие на работу алгоритма - число k, по которому на первом этапе строится граф по принципу k ближайших соседей, и два параметра <math>{T_{ri}}</math> и <math>{T_{rc}}</math>, используемые на третьем этапе для того, что определить, что не нужно далее продолжать кластеризацию.

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

На первом этапе строится граф <math>G(V,E)</math>, <math>V</math> - множество вершин, <math>E</math> - множество ребер, по принципу k ближайших соседей. Изначально граф состоит из множества вершин и пустого множества ребер. Для каждой вершины графа мы выбираем k других вершин, расстояния до которых минимальны (то есть k первых вершин в списке вершин графа, упорядоченных по увеличению расстояния до данной) и добавляем в множество ребер соответствующие ребра, соединяющие данную вершину с каждой из выбранных k вершин.

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

Состоит в итеративном разбиении графа на множество подграфов. Изначально (на первой итерации) разбиение состоит из единственного подграфа. Пусть <math>T</math> - множество подграфов на текущей итерации. Каждая итерация выполняется следующим образом - выбирается максимальный подграф из имеющихся в разбиении по числу вершин (то есть такой подграф <math>G_1(V_1,E_1)\in{T}: \forall {G_2(V_2,E_2)\in{T}: G_2\neq G_1} => |(V_1)|>|(V_2)|</math> ). Выбранный подграф разбивается на 2 подграфа следующим образом - сначала выбираются все разбиения <math>G_2(V_2,E_2)</math> и <math>G_3(V_3,E_3)</math>, такие, что <math>\min(|V_2|,|V_3|)\geq\frac{|V_1|}{4}</math>. Далее среди всех таких разбиений выбирается такое, для которого величина <math>\sum{|E_1^*|},E_1^* </math>- некое ребро, ведущее из вершины, попавшей в <math>G_2</math> в вершину, попавшую в <math>G_3</math>. В определенный момент, когда размер наибольшего кластера <math>|V_b|\leq{q*|V|}</math>, где <math>|V|</math> - количество вершин в изначальном графе, а <math>q</math> - предварительно заданный параметр, процесс дальнейшего разибения прекращается и алгоритм переходи на 3-й этап

'''Третий этап алгоритма:'''

Введем несколько определений:

Абсолютной взаимной связностью пары кластеров называется величина <math>EC_{({C_i},{C_j})}</math>, вычисляется как сумма весов ребер, соединяющих вершина 1-го кластера <math>C_i</math> с вершинами второго кластера <math>C_j</math>. Внутренняя связность кластера <math>E_{C_i}</math>вычисляется как сумма весов ребер, входящих в разделитель, разбивающих <math>C_i</math> на 2 равных подграфа.

Относительная взаимная связность пары кластеров <math>RI_{(C_i,C_j)}</math> вычисляется по формуле <math>RI_{(C_i,C_j)}=\frac{2*|EC_{(C_i,C_j)}|}{|EC_{C_i}|+|EC_{C_j}|}</math>

Абсолютное взаимное сходство пары кластеров <math>S_{E_{(C_i,C_j)}}</math>вычисляется как среднее сходство между связанными вершинами <math>C_i</math> и <math>C_j</math>

Относительное взаимное сходство пары кластеров <math>C_i</math> и <math>C_j</math> обозначается <math>RC_{(C_i,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_j|}{|C_i|+|C_j|}*S_{EC_{(C_j)}}}}</math>

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

Есть два различных подхода анализа сходства.

Первый - для каждой пары кластеров проверяется истинность следующих высказываний

<math>RI(Ci,Cj)\geq{T_{RI}} </math> и <math>RC_{(C_{i},C_{j})}\geq{T_{RC}}</math>

В случае, если для некоторого <math>C_i</math> существует несколько кластеров <math>C_j</math>, удовлетворяющих этим условиям, выбирается такой <math>C_j</math>, что

значение <math>EC_{(C_i,C_j)}</math> максимально.

Процесс останавливается, когда нет кластеров, удовлетворяющих указанным условиям (либо когда остался только 1 кластер)

Второй подход - выбирается такая пара кластеров, что <math>RI_{(C_i,C_j)}*RC^\alpha_{(C_i,C_j)}</math> максимально, где <math>\alpha</math> - заданный заранее параметр.

Процесс останавливается, когда нет кластеров, удовлетворяющих указанным условиям (либо когда остался только 1 кластер)
<ref name="chamel">http://www-users.cs.umn.edu/~han/dmclass/chameleon.pdf</ref>

=== Вычислительное ядро алгоритма ===
На первом этапе вычислительное ядро состоит из построения графа k ближайших соседей по исходной матрице смежности (требуется для каждой вершины перебрать всех соседей и выделить k ближайших)

На втором этапе вычислительное ядро состоит из повторяющегося нахождения разбиения графа на два подграфа, удовлетворяющего ранее описанным условиям

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

=== Макроструктура алгоритма ===
1. Построение графа k-ближайших соседей по исходным данным

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

3. Итеративно осуществляется обхединение подграфов, на основе метрик взаимной связности и взаимного сходства. Процесс объединения завершается в момент достижения целевых показателей по данным метрикам.

=== Схема реализации последовательного алгоритма ===
Схема представлена в виде C++-подобного псевдокода, макрооперации в алгоритме выделены в соответствии с предыдущим разделом описания.
int n; // Количество точек.
int k; // Параметр k
int Dist[n][n]; // Матрица расстояний между точками.

integer E[n][n]; // Матрица рёбер графа

foreach (int i=0; i<n; i++) ) {
integer KNeighbours[k]; // список, используемый для хранения ближайших соседей
integer countN = 0;

foreach (int j=i+1; j<n; j++ ) {
//Заполняем список k ближайших соседей по матрице Dist
}

foreach (int j=0; j<k; j++) {
E[i][KNeighbours[j]] = 1;
}
}
return E;

double q; //Параметр, описание находится в соответствующем разделе.
Graph g = getBiggestGraph(); //Находим граф максимального размера
int maxSize = getSize(g); //Находим размер данного графа
while (maxSize > n * q) {
breakGraph(g); // Разбиваем граф
}

Graph graphs[m]; //Разбиение по кластерам
while (count(graphs)>1){
pairs_exist = false //Значение будет обновлено позже, если найдется подходящая пара для объединения
for (int i = 0; i < m; i++) {
for (int j = i + 1; j < m; j++) {
if (checkSimilarity(graphs[i],graphs[j])) { //Проверяем, достаточно ли схожи графы для объединения
unite(graphs[i], graphs[l])
} else {
break;
}
}
}
}

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

На втором этапе для итеративного разбиения требуется <math>O(nm)</math>операций, где <math>n</math> - количество вершин графа, а <math>m</math> - количество подграфов в итоговом разбиении.

На третьем этапе требуется <math>O(m^2logm)</math> операций, причем вычисление метрики считается за одну операцию.

Итоговая оценка последовательной сложности <math>O(n^2)+O(nm)+O(m^2logm)</math>

=== Информационный граф ===
[[Файл:Инфограф.png]]

=== Ресурс параллелизма алгоритма ===
На первом этапе вычисление <math>k</math> ближайших вершин для <math>i</math>-й вершины можно распараллелить между <math>n</math> процессами (это вычисление независимо для каждой вершины).
На втором и третьем этапах процессы разбиения и объединения подграфов происходят последовательно.
Получаем оценку параллельной сложности алгоритма <math>O(nm)+O(m^2logm)</math>

=== Входные и выходные данные алгоритма ===
На вход алгоритму подается множество из <math>n</math> векторов длины <math>l</math>, описывающих объекты для кластеризации.
Также передаются параметры <math>k</math> (для построения графа k ближайших соседей на первом этапе) и <math>q</math> (используется на втором этапе для определения критерия прекращения итерационного процесса).
На выходе алгоритм выдает массив длины <math>n</math>, заполненный числами от <math>1</math> до <math>n</math>, показывающими, в какой кластер попал соответствующий объект.

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

Вычислительная мощность (соотношение времени выполнения и объема входных и выходных данных) для разных этапов:

<math>O(1)</math> для первого этапа

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

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

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

==Программная реализация алгоритма==
===Особенности реализации последовательного алгоритма===
===Локальность данных и вычислений===
===Возможные способы и особенности параллельной реализации алгоритма===
===Масштабируемость алгоритма и его реализации===
[[Файл:Chameleo.png|300px]]

На приведенном графике видна зависимость эффективности от объема данных и числа процессоров для реализации алгоритма, описанной в <ref name="real">http://research.ijcaonline.org/volume79/number8/pxc3891600.pdf</ref>
Для тестирования использовался процессор Intel Pentium IV для одного потока, Intel Core i5 для 4-х потоков и Intel Core i7 для 8 потоков.

К сожалению, в исследовании, на основе которого строится данный график, не приведены более подробные данные о том, как именно запускались тесты. Приводится только информация о процессорах, на которых выполнялись вычисления. Также в исследовании не приведён запускавшийся код. Вместе с тем, данное исследование является единственным, опирающимся на параллельный код и приводящее результаты запуска данного кода. Других параллельных реализаций найдено не было.

График построен для экспериментальной версии алгоритма для малого числа потоков.

===Динамические характеристики и эффективность реализации алгоритма===
===Выводы для классов архитектур===
===Существующие реализации алгоритма===
Одна из последовательных реализаций алгоритма находится по ссылке [http://codeforge.com/article/192925]

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

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

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

2017-02-03T13:40:36Z

Hromovalexander: /* Макроструктура алгоритма */

Автор статьи: Хромов А. К.

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

=== Общее описание алгоритма ===
Алгоритм CHAMELEON - алгоритм динамической иерархической кластеризации графа.
<ref name="studo">http://studopedia.ru/7_41934_algoritm-dinamicheskoy-ierarhicheskoy-klasterizatsii-CHAMELEON.html</ref>
Кластеризация - разбиение графа на несколько подграфов таким образом, чтобы объекты внутри одного кластера были максимально близки (схожи), а данные двух различных кластеров максимально различались. Различие и схожесть объектов определяются некоей метрикой, известной заранее. Количество кластеров, на которые будет разбит граф, заранее неизвестно, и зависит от свойств объекта и выбранной метрики. Простейшей возможной метриков является расстояние между точками (если предполагать, что у каждой вершины графа есть координаты).

Алгоритм состоит из 3-х основных этапов:

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

2-й этап заключается в разбиении построенного графа на небольшие кластеры (связные подграфы)

3-й этап состоит в формировании итогового множества кластеров

=== Математическое описание алгоритма ===
'''Исходные данные'''

Множество из n объектов и заданные расстояния между объектами. Эта информация позволяет построить матрицу смежности, в которой будут указаны расстояния между соответствующими объектами по некой метрике. Матрица смежности симметрична, на главной диагонали стоят 0, поэтому достаточно хранить <math>\frac{n(n-1)}{2}</math> элементов. Кроме того задаются параметры, влияющие на работу алгоритма - число k, по которому на первом этапе строится граф по принципу k ближайших соседей, и два параметра <math>{T_{ri}}</math> и <math>{T_{rc}}</math>, используемые на третьем этапе для того, что определить, что не нужно далее продолжать кластеризацию.

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

На первом этапе строится граф <math>G(V,E)</math>, <math>V</math> - множество вершин, <math>E</math> - множество ребер, по принципу k ближайших соседей. Изначально граф состоит из множества вершин и пустого множества ребер. Для каждой вершины графа мы выбираем k других вершин, расстояния до которых минимальны (то есть k первых вершин в списке вершин графа, упорядоченных по увеличению расстояния до данной) и добавляем в множество ребер соответствующие ребра, соединяющие данную вершину с каждой из выбранных k вершин.

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

Состоит в итеративном разбиении графа на множество подграфов. Изначально (на первой итерации) разбиение состоит из единственного подграфа. Пусть <math>T</math> - множество подграфов на текущей итерации. Каждая итерация выполняется следующим образом - выбирается максимальный подграф из имеющихся в разбиении по числу вершин (то есть такой подграф <math>G_1(V_1,E_1)\in{T}: \forall {G_2(V_2,E_2)\in{T}: G_2\neq G_1} => |(V_1)|>|(V_2)|</math> ). Выбранный подграф разбивается на 2 подграфа следующим образом - сначала выбираются все разбиения <math>G_2(V_2,E_2)</math> и <math>G_3(V_3,E_3)</math>, такие, что <math>\min(|V_2|,|V_3|)\geq\frac{|V_1|}{4}</math>. Далее среди всех таких разбиений выбирается такое, для которого величина <math>\sum{|E_1^*|},E_1^* </math>- некое ребро, ведущее из вершины, попавшей в <math>G_2</math> в вершину, попавшую в <math>G_3</math>. В определенный момент, когда размер наибольшего кластера <math>|V_b|\leq{q*|V|}</math>, где <math>|V|</math> - количество вершин в изначальном графе, а <math>q</math> - предварительно заданный параметр, процесс дальнейшего разибения прекращается и алгоритм переходи на 3-й этап

'''Третий этап алгоритма:'''

Введем несколько определений:

Абсолютной взаимной связностью пары кластеров называется величина <math>EC_{({C_i},{C_j})}</math>, вычисляется как сумма весов ребер, соединяющих вершина 1-го кластера <math>C_i</math> с вершинами второго кластера <math>C_j</math>. Внутренняя связность кластера <math>E_{C_i}</math>вычисляется как сумма весов ребер, входящих в разделитель, разбивающих <math>C_i</math> на 2 равных подграфа.

Относительная взаимная связность пары кластеров <math>RI_{(C_i,C_j)}</math> вычисляется по формуле <math>RI_{(C_i,C_j)}=\frac{2*|EC_{(C_i,C_j)}|}{|EC_{C_i}|+|EC_{C_j}|}</math>

Абсолютное взаимное сходство пары кластеров <math>S_{E_{(C_i,C_j)}}</math>вычисляется как среднее сходство между связанными вершинами <math>C_i</math> и <math>C_j</math>

Относительное взаимное сходство пары кластеров <math>C_i</math> и <math>C_j</math> обозначается <math>RC_{(C_i,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_j|}{|C_i|+|C_j|}*S_{EC_{(C_j)}}}}</math>

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

Есть два различных подхода анализа сходства.

Первый - для каждой пары кластеров проверяется истинность следующих высказываний

<math>RI(Ci,Cj)\geq{T_{RI}} </math> и <math>RC_{(C_{i},C_{j})}\geq{T_{RC}}</math>

В случае, если для некоторого <math>C_i</math> существует несколько кластеров <math>C_j</math>, удовлетворяющих этим условиям, выбирается такой <math>C_j</math>, что

значение <math>EC_{(C_i,C_j)}</math> максимально.

Процесс останавливается, когда нет кластеров, удовлетворяющих указанным условиям (либо когда остался только 1 кластер)

Второй подход - выбирается такая пара кластеров, что <math>RI_{(C_i,C_j)}*RC^\alpha_{(C_i,C_j)}</math> максимально, где <math>\alpha</math> - заданный заранее параметр.

Процесс останавливается, когда нет кластеров, удовлетворяющих указанным условиям (либо когда остался только 1 кластер)
<ref name="chamel">http://www-users.cs.umn.edu/~han/dmclass/chameleon.pdf</ref>

=== Вычислительное ядро алгоритма ===
На первом этапе вычислительное ядро состоит из построения графа k ближайших соседей по исходной матрице смежности (требуется для каждой вершины перебрать всех соседей и выделить k ближайших)

На втором этапе вычислительное ядро состоит из повторяющегося нахождения разбиения графа на два подграфа, удовлетворяющего ранее описанным условиям

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

=== Макроструктура алгоритма ===
1. Построение графа k-ближайших соседей по исходным данным

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

3. Итеративно осуществляется обхединение подграфов, на основе метрик взаимной связности и взаимного сходства. Процесс объединения завершается в момент достижения целевых показателей по данным метрикам.

=== Схема реализации последовательного алгоритма ===
Схема представлена в виде C++-подобного псевдокода, макрооперации в алгоритме выделены в соответствии с предыдущим разделом описания.
int n; // Количество точек.
int k; // Параметр k
int Dist[n][n]; // Матрица расстояний между точками.

integer E[n][n]; // Матрица рёбер графа

foreach (int i=0; i<n; i++) ) {
integer KNeighbours[k]; // список, используемый для хранения ближайших соседей
integer countN = 0;

foreach (int j=i+1; j<n; j++ ) {
//Заполняем список k ближайших соседей по матрице Dist
}

foreach (int j=0; j<k; j++) {
E[i][KNeighbours[j]] = 1;
}
}
return E;

double q; //Параметр, описание находится в соответствующем разделе.
Graph g = getBiggestGraph(); //Находим граф максимального размера
int maxSize = getSize(g); //Находим размер данного графа
while (maxSize > n * q) {
breakGraph(g); // Разбиваем граф
}

Graph graphs[m]; //Разбиение по кластерам
while (count(graphs)>1){
pairs_exist = false //Значение будет обновлено позже, если найдется подходящая пара для объединения
for (int i = 0; i < m; i++) {
for (int j = i + 1; j < m; j++) {
if (checkSimilarity(graphs[i],graphs[j])) { //Проверяем, достаточно ли схожи графы для объединения
unite(graphs[i], graphs[l])
} else {
break;
}
}
}
}

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

На втором этапе для итеративного разбиения требуется <math>O(nm)</math>операций, где <math>n</math> - количество вершин графа, а <math>m</math> - количество подграфов в итоговом разбиении.

На третьем этапе требуется <math>O(m^2logm)</math> операций, причем вычисление метрики считается за одну операцию.

Итоговая оценка последовательной сложности <math>O(n^2)+O(nm)+O(m^2logm)</math>

=== Информационный граф ===
[[Файл:Инфограф.png]]

=== Ресурс параллелизма алгоритма ===
На первом этапе вычисление <math>k</math> ближайших вершин для <math>i</math>-й вершины можно распараллелить между <math>n</math> процессами (это вычисление независимо для каждой вершины).
На втором и третьем этапах процессы разбиения и объединения подграфов происходят последовательно.
Получаем оценку параллельной сложности алгоритма <math>O(nm)+O(m^2logm)</math>

=== Входные и выходные данные алгоритма ===
На вход алгоритму подается множество из <math>n</math> векторов длины <math>l</math>, описывающих объекты для кластеризации.
Также передаются параметры <math>k</math> (для построения графа k ближайших соседей на первом этапе) и <math>q</math> (используется на втором этапе для определения критерия прекращения итерационного процесса).
На выходе алгоритм выдает массив длины <math>n</math>, заполненный числами от <math>1</math> до <math>n</math>, показывающими, в какой кластер попал соответствующий объект.

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

Вычислительная мощность (соотношение времени выполнения и объема входных и выходных данных) для разных этапов:

<math>O(1)</math> для первого этапа

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

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

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

==Программная реализация алгоритма==
===Особенности реализации последовательного алгоритма===
===Локальность данных и вычислений===
===Возможные способы и особенности параллельной реализации алгоритма===
===Масштабируемость алгоритма и его реализации===
[[Файл:Chameleo.png|300px]]

На приведенном графике видна зависимость эффективности от объема данных и числа процессоров для реализации алгоритма, описанной в <ref name="real">http://research.ijcaonline.org/volume79/number8/pxc3891600.pdf</ref>

График построен для экспериментальной версии алгоритма для малого числа потоков.

===Динамические характеристики и эффективность реализации алгоритма===
===Выводы для классов архитектур===
===Существующие реализации алгоритма===
Одна из последовательных реализаций алгоритма находится по ссылке [http://codeforge.com/article/192925]

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

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

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

2017-02-03T13:40:08Z

Hromovalexander: /* Макроструктура алгоритма */

Автор статьи: Хромов А. К.

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

=== Общее описание алгоритма ===
Алгоритм CHAMELEON - алгоритм динамической иерархической кластеризации графа.
<ref name="studo">http://studopedia.ru/7_41934_algoritm-dinamicheskoy-ierarhicheskoy-klasterizatsii-CHAMELEON.html</ref>
Кластеризация - разбиение графа на несколько подграфов таким образом, чтобы объекты внутри одного кластера были максимально близки (схожи), а данные двух различных кластеров максимально различались. Различие и схожесть объектов определяются некоей метрикой, известной заранее. Количество кластеров, на которые будет разбит граф, заранее неизвестно, и зависит от свойств объекта и выбранной метрики. Простейшей возможной метриков является расстояние между точками (если предполагать, что у каждой вершины графа есть координаты).

Алгоритм состоит из 3-х основных этапов:

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

2-й этап заключается в разбиении построенного графа на небольшие кластеры (связные подграфы)

3-й этап состоит в формировании итогового множества кластеров

=== Математическое описание алгоритма ===
'''Исходные данные'''

Множество из n объектов и заданные расстояния между объектами. Эта информация позволяет построить матрицу смежности, в которой будут указаны расстояния между соответствующими объектами по некой метрике. Матрица смежности симметрична, на главной диагонали стоят 0, поэтому достаточно хранить <math>\frac{n(n-1)}{2}</math> элементов. Кроме того задаются параметры, влияющие на работу алгоритма - число k, по которому на первом этапе строится граф по принципу k ближайших соседей, и два параметра <math>{T_{ri}}</math> и <math>{T_{rc}}</math>, используемые на третьем этапе для того, что определить, что не нужно далее продолжать кластеризацию.

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

На первом этапе строится граф <math>G(V,E)</math>, <math>V</math> - множество вершин, <math>E</math> - множество ребер, по принципу k ближайших соседей. Изначально граф состоит из множества вершин и пустого множества ребер. Для каждой вершины графа мы выбираем k других вершин, расстояния до которых минимальны (то есть k первых вершин в списке вершин графа, упорядоченных по увеличению расстояния до данной) и добавляем в множество ребер соответствующие ребра, соединяющие данную вершину с каждой из выбранных k вершин.

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

Состоит в итеративном разбиении графа на множество подграфов. Изначально (на первой итерации) разбиение состоит из единственного подграфа. Пусть <math>T</math> - множество подграфов на текущей итерации. Каждая итерация выполняется следующим образом - выбирается максимальный подграф из имеющихся в разбиении по числу вершин (то есть такой подграф <math>G_1(V_1,E_1)\in{T}: \forall {G_2(V_2,E_2)\in{T}: G_2\neq G_1} => |(V_1)|>|(V_2)|</math> ). Выбранный подграф разбивается на 2 подграфа следующим образом - сначала выбираются все разбиения <math>G_2(V_2,E_2)</math> и <math>G_3(V_3,E_3)</math>, такие, что <math>\min(|V_2|,|V_3|)\geq\frac{|V_1|}{4}</math>. Далее среди всех таких разбиений выбирается такое, для которого величина <math>\sum{|E_1^*|},E_1^* </math>- некое ребро, ведущее из вершины, попавшей в <math>G_2</math> в вершину, попавшую в <math>G_3</math>. В определенный момент, когда размер наибольшего кластера <math>|V_b|\leq{q*|V|}</math>, где <math>|V|</math> - количество вершин в изначальном графе, а <math>q</math> - предварительно заданный параметр, процесс дальнейшего разибения прекращается и алгоритм переходи на 3-й этап

'''Третий этап алгоритма:'''

Введем несколько определений:

Абсолютной взаимной связностью пары кластеров называется величина <math>EC_{({C_i},{C_j})}</math>, вычисляется как сумма весов ребер, соединяющих вершина 1-го кластера <math>C_i</math> с вершинами второго кластера <math>C_j</math>. Внутренняя связность кластера <math>E_{C_i}</math>вычисляется как сумма весов ребер, входящих в разделитель, разбивающих <math>C_i</math> на 2 равных подграфа.

Относительная взаимная связность пары кластеров <math>RI_{(C_i,C_j)}</math> вычисляется по формуле <math>RI_{(C_i,C_j)}=\frac{2*|EC_{(C_i,C_j)}|}{|EC_{C_i}|+|EC_{C_j}|}</math>

Абсолютное взаимное сходство пары кластеров <math>S_{E_{(C_i,C_j)}}</math>вычисляется как среднее сходство между связанными вершинами <math>C_i</math> и <math>C_j</math>

Относительное взаимное сходство пары кластеров <math>C_i</math> и <math>C_j</math> обозначается <math>RC_{(C_i,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_j|}{|C_i|+|C_j|}*S_{EC_{(C_j)}}}}</math>

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

Есть два различных подхода анализа сходства.

Первый - для каждой пары кластеров проверяется истинность следующих высказываний

<math>RI(Ci,Cj)\geq{T_{RI}} </math> и <math>RC_{(C_{i},C_{j})}\geq{T_{RC}}</math>

В случае, если для некоторого <math>C_i</math> существует несколько кластеров <math>C_j</math>, удовлетворяющих этим условиям, выбирается такой <math>C_j</math>, что

значение <math>EC_{(C_i,C_j)}</math> максимально.

Процесс останавливается, когда нет кластеров, удовлетворяющих указанным условиям (либо когда остался только 1 кластер)

Второй подход - выбирается такая пара кластеров, что <math>RI_{(C_i,C_j)}*RC^\alpha_{(C_i,C_j)}</math> максимально, где <math>\alpha</math> - заданный заранее параметр.

Процесс останавливается, когда нет кластеров, удовлетворяющих указанным условиям (либо когда остался только 1 кластер)
<ref name="chamel">http://www-users.cs.umn.edu/~han/dmclass/chameleon.pdf</ref>

=== Вычислительное ядро алгоритма ===
На первом этапе вычислительное ядро состоит из построения графа k ближайших соседей по исходной матрице смежности (требуется для каждой вершины перебрать всех соседей и выделить k ближайших)

На втором этапе вычислительное ядро состоит из повторяющегося нахождения разбиения графа на два подграфа, удовлетворяющего ранее описанным условиям

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

=== Макроструктура алгоритма ===
1. Построение графа k-ближайших соседей по исходным данным
2. Разбиения полученного на первом этапе графа на множество подграфов. На очередной итерации выбирается максимальный подграф, для него определяется оптимальное разбиение (подробнее описано в разделе 1.2), подграф разбивается в соответсвии с данным разбиением, начинается следующая итерация. В определенный момент, когда количество вершни в максимальном подграфе становится меньше, чем некоторая изначально заданная доля от количества вершин в первоначальном графе, разбиение прекращается.
3. Итеративно осуществляется обхединение подграфов, на основе метрик взаимной связности и взаимного сходства. Процесс объединения завершается в момент достижения целевых показателей по данным метрикам.

=== Схема реализации последовательного алгоритма ===
Схема представлена в виде C++-подобного псевдокода, макрооперации в алгоритме выделены в соответствии с предыдущим разделом описания.
int n; // Количество точек.
int k; // Параметр k
int Dist[n][n]; // Матрица расстояний между точками.

integer E[n][n]; // Матрица рёбер графа

foreach (int i=0; i<n; i++) ) {
integer KNeighbours[k]; // список, используемый для хранения ближайших соседей
integer countN = 0;

foreach (int j=i+1; j<n; j++ ) {
//Заполняем список k ближайших соседей по матрице Dist
}

foreach (int j=0; j<k; j++) {
E[i][KNeighbours[j]] = 1;
}
}
return E;

double q; //Параметр, описание находится в соответствующем разделе.
Graph g = getBiggestGraph(); //Находим граф максимального размера
int maxSize = getSize(g); //Находим размер данного графа
while (maxSize > n * q) {
breakGraph(g); // Разбиваем граф
}

Graph graphs[m]; //Разбиение по кластерам
while (count(graphs)>1){
pairs_exist = false //Значение будет обновлено позже, если найдется подходящая пара для объединения
for (int i = 0; i < m; i++) {
for (int j = i + 1; j < m; j++) {
if (checkSimilarity(graphs[i],graphs[j])) { //Проверяем, достаточно ли схожи графы для объединения
unite(graphs[i], graphs[l])
} else {
break;
}
}
}
}

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

На втором этапе для итеративного разбиения требуется <math>O(nm)</math>операций, где <math>n</math> - количество вершин графа, а <math>m</math> - количество подграфов в итоговом разбиении.

На третьем этапе требуется <math>O(m^2logm)</math> операций, причем вычисление метрики считается за одну операцию.

Итоговая оценка последовательной сложности <math>O(n^2)+O(nm)+O(m^2logm)</math>

=== Информационный граф ===
[[Файл:Инфограф.png]]

=== Ресурс параллелизма алгоритма ===
На первом этапе вычисление <math>k</math> ближайших вершин для <math>i</math>-й вершины можно распараллелить между <math>n</math> процессами (это вычисление независимо для каждой вершины).
На втором и третьем этапах процессы разбиения и объединения подграфов происходят последовательно.
Получаем оценку параллельной сложности алгоритма <math>O(nm)+O(m^2logm)</math>

=== Входные и выходные данные алгоритма ===
На вход алгоритму подается множество из <math>n</math> векторов длины <math>l</math>, описывающих объекты для кластеризации.
Также передаются параметры <math>k</math> (для построения графа k ближайших соседей на первом этапе) и <math>q</math> (используется на втором этапе для определения критерия прекращения итерационного процесса).
На выходе алгоритм выдает массив длины <math>n</math>, заполненный числами от <math>1</math> до <math>n</math>, показывающими, в какой кластер попал соответствующий объект.

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

Вычислительная мощность (соотношение времени выполнения и объема входных и выходных данных) для разных этапов:

<math>O(1)</math> для первого этапа

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

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

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

==Программная реализация алгоритма==
===Особенности реализации последовательного алгоритма===
===Локальность данных и вычислений===
===Возможные способы и особенности параллельной реализации алгоритма===
===Масштабируемость алгоритма и его реализации===
[[Файл:Chameleo.png|300px]]

На приведенном графике видна зависимость эффективности от объема данных и числа процессоров для реализации алгоритма, описанной в <ref name="real">http://research.ijcaonline.org/volume79/number8/pxc3891600.pdf</ref>

График построен для экспериментальной версии алгоритма для малого числа потоков.

===Динамические характеристики и эффективность реализации алгоритма===
===Выводы для классов архитектур===
===Существующие реализации алгоритма===
Одна из последовательных реализаций алгоритма находится по ссылке [http://codeforge.com/article/192925]

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

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

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

2017-01-30T21:24:01Z

Hromovalexander:

{{assignment}}
Автор статьи: Хромов А. К.

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

=== Общее описание алгоритма ===
Алгоритм CHAMELEON - алгоритм динамической иерархической кластеризации графа.
<ref name="studo">http://studopedia.ru/7_41934_algoritm-dinamicheskoy-ierarhicheskoy-klasterizatsii-CHAMELEON.html</ref>
Кластеризация - разбиение графа на несколько подграфов таким образом, чтобы объекты внутри одного кластера были максимально близки (схожи), а данные двух различных кластеров максимально различались. Различие и схожесть объектов определяются некоей метрикой, известной заранее. Количество кластеров, на которые будет разбит граф, заранее неизвестно, и зависит от свойств объекта и выбранной метрики. Простейшей возможной метриков является расстояние между точками (если предполагать, что у каждой вершины графа есть координаты).

Алгоритм состоит из 3-х основных этапов:

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

2-й этап заключается в разбиении построенного графа на небольшие кластеры (связные подграфы)

3-й этап состоит в формировании итогового множества кластеров

=== Математическое описание алгоритма ===
'''Исходные данные'''

Множество из n объектов и заданные расстояния между объектами. Эта информация позволяет построить матрицу смежности, в которой будут указаны расстояния между соответствующими объектами по некой метрике. Матрица смежности симметрична, на главной диагонали стоят 0, поэтому достаточно хранить <math>\frac{n(n-1)}{2}</math> элементов. Кроме того задаются параметры, влияющие на работу алгоритма - число k, по которому на первом этапе строится граф по принципу k ближайших соседей, и два параметра <math>{T_{ri}}</math> и <math>{T_{rc}}</math>, используемые на третьем этапе для того, что определить, что не нужно далее продолжать кластеризацию.

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

На первом этапе строится граф <math>G(V,E)</math>, <math>V</math> - множество вершин, <math>E</math> - множество ребер, по принципу k ближайших соседей. Изначально граф состоит из множества вершин и пустого множества ребер. Для каждой вершины графа мы выбираем k других вершин, расстояния до которых минимальны (то есть k первых вершин в списке вершин графа, упорядоченных по увеличению расстояния до данной) и добавляем в множество ребер соответствующие ребра, соединяющие данную вершину с каждой из выбранных k вершин.

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

Состоит в итеративном разбиении графа на множество подграфов. Изначально (на первой итерации) разбиение состоит из единственного подграфа. Пусть <math>T</math> - множество подграфов на текущей итерации. Каждая итерация выполняется следующим образом - выбирается максимальный подграф из имеющихся в разбиении по числу вершин (то есть такой подграф <math>G_1(V_1,E_1)\in{T}: \forall {G_2(V_2,E_2)\in{T}: G_2\neq G_1} => |(V_1)|>|(V_2)|</math> ). Выбранный подграф разбивается на 2 подграфа следующим образом - сначала выбираются все разбиения <math>G_2(V_2,E_2)</math> и <math>G_3(V_3,E_3)</math>, такие, что <math>\min(|V_2|,|V_3|)\geq\frac{|V_1|}{4}</math>. Далее среди всех таких разбиений выбирается такое, для которого величина <math>\sum{|E_1^*|},E_1^* </math>- некое ребро, ведущее из вершины, попавшей в <math>G_2</math> в вершину, попавшую в <math>G_3</math>. В определенный момент, когда размер наибольшего кластера <math>|V_b|\leq{q*|V|}</math>, где <math>|V|</math> - количество вершин в изначальном графе, а <math>q</math> - предварительно заданный параметр, процесс дальнейшего разибения прекращается и алгоритм переходи на 3-й этап

'''Третий этап алгоритма:'''

Введем несколько определений:

Абсолютной взаимной связностью пары кластеров называется величина <math>EC_{({C_i},{C_j})}</math>, вычисляется как сумма весов ребер, соединяющих вершина 1-го кластера <math>C_i</math> с вершинами второго кластера <math>C_j</math>. Внутренняя связность кластера <math>E_{C_i}</math>вычисляется как сумма весов ребер, входящих в разделитель, разбивающих <math>C_i</math> на 2 равных подграфа.

Относительная взаимная связность пары кластеров <math>RI_{(C_i,C_j)}</math> вычисляется по формуле <math>RI_{(C_i,C_j)}=\frac{2*|EC_{(C_i,C_j)}|}{|EC_{C_i}|+|EC_{C_j}|}</math>

Абсолютное взаимное сходство пары кластеров <math>S_{E_{(C_i,C_j)}}</math>вычисляется как среднее сходство между связанными вершинами <math>C_i</math> и <math>C_j</math>

Относительное взаимное сходство пары кластеров <math>C_i</math> и <math>C_j</math> обозначается <math>RC_{(C_i,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_j|}{|C_i|+|C_j|}*S_{EC_{(C_j)}}}}</math>

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

Есть два различных подхода анализа сходства.

Первый - для каждой пары кластеров проверяется истинность следующих высказываний

<math>RI(Ci,Cj)\geq{T_{RI}} </math> и <math>RC_{(C_{i},C_{j})}\geq{T_{RC}}</math>

В случае, если для некоторого <math>C_i</math> существует несколько кластеров <math>C_j</math>, удовлетворяющих этим условиям, выбирается такой <math>C_j</math>, что

значение <math>EC_{(C_i,C_j)}</math> максимально.

Процесс останавливается, когда нет кластеров, удовлетворяющих указанным условиям (либо когда остался только 1 кластер)

Второй подход - выбирается такая пара кластеров, что <math>RI_{(C_i,C_j)}*RC^\alpha_{(C_i,C_j)}</math> максимально, где <math>\alpha</math> - заданный заранее параметр.

Процесс останавливается, когда нет кластеров, удовлетворяющих указанным условиям (либо когда остался только 1 кластер)
<ref name="chamel">http://www-users.cs.umn.edu/~han/dmclass/chameleon.pdf</ref>

=== Вычислительное ядро алгоритма ===
На первом этапе вычислительное ядро состоит из построения графа k ближайших соседей по исходной матрице смежности (требуется для каждой вершины перебрать всех соседей и выделить k ближайших)

На втором этапе вычислительное ядро состоит из повторяющегося нахождения разбиения графа на два подграфа, удовлетворяющего ранее описанным условиям

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

=== Макроструктура алгоритма ===
В рамках первого этапа макрооперацияй считается построение графа k-ближайших соседей

В рамках второго этапа макрооперациями считаются операции разбиения подграфа.

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

=== Схема реализации последовательного алгоритма ===
Схема представлена в виде C++-подобного псевдокода, макрооперации в алгоритме выделены в соответствии с предыдущим разделом описания.
int n; // Количество точек.
int k; // Параметр k
int Dist[n][n]; // Матрица расстояний между точками.

integer E[n][n]; // Матрица рёбер графа

foreach (int i=0; i<n; i++) ) {
integer KNeighbours[k]; // список, используемый для хранения ближайших соседей
integer countN = 0;

foreach (int j=i+1; j<n; j++ ) {
//Заполняем список k ближайших соседей по матрице Dist
}

foreach (int j=0; j<k; j++) {
E[i][KNeighbours[j]] = 1;
}
}
return E;

double q; //Параметр, описание находится в соответствующем разделе.
Graph g = getBiggestGraph(); //Находим граф максимального размера
int maxSize = getSize(g); //Находим размер данного графа
while (maxSize > n * q) {
breakGraph(g); // Разбиваем граф
}

Graph graphs[m]; //Разбиение по кластерам
while (count(graphs)>1){
pairs_exist = false //Значение будет обновлено позже, если найдется подходящая пара для объединения
for (int i = 0; i < m; i++) {
for (int j = i + 1; j < m; j++) {
if (checkSimilarity(graphs[i],graphs[j])) { //Проверяем, достаточно ли схожи графы для объединения
unite(graphs[i], graphs[l])
} else {
break;
}
}
}
}

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

На втором этапе для итеративного разбиения требуется <math>O(nm)</math>операций, где <math>n</math> - количество вершин графа, а <math>m</math> - количество подграфов в итоговом разбиении.

На третьем этапе требуется <math>O(m^2logm)</math> операций, причем вычисление метрики считается за одну операцию.

Итоговая оценка последовательной сложности <math>O(n^2)+O(nm)+O(m^2logm)</math>

=== Информационный граф ===
[[Файл:Инфограф.png]]

=== Ресурс параллелизма алгоритма ===
На первом этапе вычисление <math>k</math> ближайших вершин для <math>i</math>-й вершины можно распараллелить между <math>n</math> процессами (это вычисление независимо для каждой вершины).
На втором и третьем этапах процессы разбиения и объединения подграфов происходят последовательно.
Получаем оценку параллельной сложности алгоритма <math>O(nm)+O(m^2logm)</math>

=== Входные и выходные данные алгоритма ===
На вход алгоритму подается множество из <math>n</math> векторов длины <math>l</math>, описывающих объекты для кластеризации.
Также передаются параметры <math>k</math> (для построения графа k ближайших соседей на первом этапе) и <math>q</math> (используется на втором этапе для определения критерия прекращения итерационного процесса).
На выходе алгоритм выдает массив длины <math>n</math>, заполненный числами от <math>1</math> до <math>n</math>, показывающими, в какой кластер попал соответствующий объект.

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

Вычислительная мощность (соотношение времени выполнения и объема входных и выходных данных) для разных этапов:

<math>O(1)</math> для первого этапа

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

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

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

==Программная реализация алгоритма==
===Особенности реализации последовательного алгоритма===
===Локальность данных и вычислений===
===Возможные способы и особенности параллельной реализации алгоритма===
===Масштабируемость алгоритма и его реализации===
[[Файл:Chameleo.png|300px]]

На приведенном графике видна зависимость эффективности от объема данных и числа процессоров для реализации алгоритма, описанной в <ref name="real">http://research.ijcaonline.org/volume79/number8/pxc3891600.pdf</ref>

График построен для экспериментальной версии алгоритма для малого числа потоков.

===Динамические характеристики и эффективность реализации алгоритма===
===Выводы для классов архитектур===
===Существующие реализации алгоритма===
Одна из последовательных реализаций алгоритма находится по ссылке [http://codeforge.com/article/192925]

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

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

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

2017-01-30T21:20:52Z

Hromovalexander:

{{В инкубаторе}}
Автор статьи: Хромов А. К.

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

=== Общее описание алгоритма ===
Алгоритм CHAMELEON - алгоритм динамической иерархической кластеризации графа.
<ref name="studo">http://studopedia.ru/7_41934_algoritm-dinamicheskoy-ierarhicheskoy-klasterizatsii-CHAMELEON.html</ref>
Кластеризация - разбиение графа на несколько подграфов таким образом, чтобы объекты внутри одного кластера были максимально близки (схожи), а данные двух различных кластеров максимально различались. Различие и схожесть объектов определяются некоей метрикой, известной заранее. Количество кластеров, на которые будет разбит граф, заранее неизвестно, и зависит от свойств объекта и выбранной метрики. Простейшей возможной метриков является расстояние между точками (если предполагать, что у каждой вершины графа есть координаты).

Алгоритм состоит из 3-х основных этапов:

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

2-й этап заключается в разбиении построенного графа на небольшие кластеры (связные подграфы)

3-й этап состоит в формировании итогового множества кластеров

=== Математическое описание алгоритма ===
'''Исходные данные'''

Множество из n объектов и заданные расстояния между объектами. Эта информация позволяет построить матрицу смежности, в которой будут указаны расстояния между соответствующими объектами по некой метрике. Матрица смежности симметрична, на главной диагонали стоят 0, поэтому достаточно хранить <math>\frac{n(n-1)}{2}</math> элементов. Кроме того задаются параметры, влияющие на работу алгоритма - число k, по которому на первом этапе строится граф по принципу k ближайших соседей, и два параметра <math>{T_{ri}}</math> и <math>{T_{rc}}</math>, используемые на третьем этапе для того, что определить, что не нужно далее продолжать кластеризацию.

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

На первом этапе строится граф <math>G(V,E)</math>, <math>V</math> - множество вершин, <math>E</math> - множество ребер, по принципу k ближайших соседей. Изначально граф состоит из множества вершин и пустого множества ребер. Для каждой вершины графа мы выбираем k других вершин, расстояния до которых минимальны (то есть k первых вершин в списке вершин графа, упорядоченных по увеличению расстояния до данной) и добавляем в множество ребер соответствующие ребра, соединяющие данную вершину с каждой из выбранных k вершин.

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

Состоит в итеративном разбиении графа на множество подграфов. Изначально (на первой итерации) разбиение состоит из единственного подграфа. Пусть <math>T</math> - множество подграфов на текущей итерации. Каждая итерация выполняется следующим образом - выбирается максимальный подграф из имеющихся в разбиении по числу вершин (то есть такой подграф <math>G_1(V_1,E_1)\in{T}: \forall {G_2(V_2,E_2)\in{T}: G_2\neq G_1} => |(V_1)|>|(V_2)|</math> ). Выбранный подграф разбивается на 2 подграфа следующим образом - сначала выбираются все разбиения <math>G_2(V_2,E_2)</math> и <math>G_3(V_3,E_3)</math>, такие, что <math>\min(|V_2|,|V_3|)\geq\frac{|V_1|}{4}</math>. Далее среди всех таких разбиений выбирается такое, для которого величина <math>\sum{|E_1^*|},E_1^* </math>- некое ребро, ведущее из вершины, попавшей в <math>G_2</math> в вершину, попавшую в <math>G_3</math>. В определенный момент, когда размер наибольшего кластера <math>|V_b|\leq{q*|V|}</math>, где <math>|V|</math> - количество вершин в изначальном графе, а <math>q</math> - предварительно заданный параметр, процесс дальнейшего разибения прекращается и алгоритм переходи на 3-й этап

'''Третий этап алгоритма:'''

Введем несколько определений:

Абсолютной взаимной связностью пары кластеров называется величина <math>EC_{({C_i},{C_j})}</math>, вычисляется как сумма весов ребер, соединяющих вершина 1-го кластера <math>C_i</math> с вершинами второго кластера <math>C_j</math>. Внутренняя связность кластера <math>E_{C_i}</math>вычисляется как сумма весов ребер, входящих в разделитель, разбивающих <math>C_i</math> на 2 равных подграфа.

Относительная взаимная связность пары кластеров <math>RI_{(C_i,C_j)}</math> вычисляется по формуле <math>RI_{(C_i,C_j)}=\frac{2*|EC_{(C_i,C_j)}|}{|EC_{C_i}|+|EC_{C_j}|}</math>

Абсолютное взаимное сходство пары кластеров <math>S_{E_{(C_i,C_j)}}</math>вычисляется как среднее сходство между связанными вершинами <math>C_i</math> и <math>C_j</math>

Относительное взаимное сходство пары кластеров <math>C_i</math> и <math>C_j</math> обозначается <math>RC_{(C_i,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_j|}{|C_i|+|C_j|}*S_{EC_{(C_j)}}}}</math>

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

Есть два различных подхода анализа сходства.

Первый - для каждой пары кластеров проверяется истинность следующих высказываний

<math>RI(Ci,Cj)\geq{T_{RI}} </math> и <math>RC_{(C_{i},C_{j})}\geq{T_{RC}}</math>

В случае, если для некоторого <math>C_i</math> существует несколько кластеров <math>C_j</math>, удовлетворяющих этим условиям, выбирается такой <math>C_j</math>, что

значение <math>EC_{(C_i,C_j)}</math> максимально.

Процесс останавливается, когда нет кластеров, удовлетворяющих указанным условиям (либо когда остался только 1 кластер)

Второй подход - выбирается такая пара кластеров, что <math>RI_{(C_i,C_j)}*RC^\alpha_{(C_i,C_j)}</math> максимально, где <math>\alpha</math> - заданный заранее параметр.

Процесс останавливается, когда нет кластеров, удовлетворяющих указанным условиям (либо когда остался только 1 кластер)
<ref name="chamel">http://www-users.cs.umn.edu/~han/dmclass/chameleon.pdf</ref>

=== Вычислительное ядро алгоритма ===
На первом этапе вычислительное ядро состоит из построения графа k ближайших соседей по исходной матрице смежности (требуется для каждой вершины перебрать всех соседей и выделить k ближайших)

На втором этапе вычислительное ядро состоит из повторяющегося нахождения разбиения графа на два подграфа, удовлетворяющего ранее описанным условиям

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

=== Макроструктура алгоритма ===
В рамках первого этапа макрооперацияй считается построение графа k-ближайших соседей

В рамках второго этапа макрооперациями считаются операции разбиения подграфа.

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

=== Схема реализации последовательного алгоритма ===
Схема представлена в виде C++-подобного псевдокода, макрооперации в алгоритме выделены в соответствии с предыдущим разделом описания.
int n; // Количество точек.
int k; // Параметр k
int Dist[n][n]; // Матрица расстояний между точками.

integer E[n][n]; // Матрица рёбер графа

foreach (int i=0; i<n; i++) ) {
integer KNeighbours[k]; // список, используемый для хранения ближайших соседей
integer countN = 0;

foreach (int j=i+1; j<n; j++ ) {
//Заполняем список k ближайших соседей по матрице Dist
}

foreach (int j=0; j<k; j++) {
E[i][KNeighbours[j]] = 1;
}
}
return E;

double q; //Параметр, описание находится в соответствующем разделе.
Graph g = getBiggestGraph(); //Находим граф максимального размера
int maxSize = getSize(g); //Находим размер данного графа
while (maxSize > n * q) {
breakGraph(g); // Разбиваем граф
}

Graph graphs[m]; //Разбиение по кластерам
while (count(graphs)>1){
pairs_exist = false //Значение будет обновлено позже, если найдется подходящая пара для объединения
for (int i = 0; i < m; i++) {
for (int j = i + 1; j < m; j++) {
if (checkSimilarity(graphs[i],graphs[j])) { //Проверяем, достаточно ли схожи графы для объединения
unite(graphs[i], graphs[l])
} else {
break;
}
}
}
}

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

На втором этапе для итеративного разбиения требуется <math>O(nm)</math>операций, где <math>n</math> - количество вершин графа, а <math>m</math> - количество подграфов в итоговом разбиении.

На третьем этапе требуется <math>O(m^2logm)</math> операций, причем вычисление метрики считается за одну операцию.

Итоговая оценка последовательной сложности <math>O(n^2)+O(nm)+O(m^2logm)</math>

=== Информационный граф ===
[[Файл:Инфограф.png]]

=== Ресурс параллелизма алгоритма ===
На первом этапе вычисление <math>k</math> ближайших вершин для <math>i</math>-й вершины можно распараллелить между <math>n</math> процессами (это вычисление независимо для каждой вершины).
На втором и третьем этапах процессы разбиения и объединения подграфов происходят последовательно.
Получаем оценку параллельной сложности алгоритма <math>O(nm)+O(m^2logm)</math>

=== Входные и выходные данные алгоритма ===
На вход алгоритму подается множество из <math>n</math> векторов длины <math>l</math>, описывающих объекты для кластеризации.
Также передаются параметры <math>k</math> (для построения графа k ближайших соседей на первом этапе) и <math>q</math> (используется на втором этапе для определения критерия прекращения итерационного процесса).
На выходе алгоритм выдает массив длины <math>n</math>, заполненный числами от <math>1</math> до <math>n</math>, показывающими, в какой кластер попал соответствующий объект.

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

Вычислительная мощность (соотношение времени выполнения и объема входных и выходных данных) для разных этапов:

<math>O(1)</math> для первого этапа

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

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

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

==Программная реализация алгоритма==
===Особенности реализации последовательного алгоритма===
===Локальность данных и вычислений===
===Возможные способы и особенности параллельной реализации алгоритма===
===Масштабируемость алгоритма и его реализации===
[[Файл:Chameleo.png|300px]]

На приведенном графике видна зависимость эффективности от объема данных и числа процессоров для реализации алгоритма, описанной в <ref name="real">http://research.ijcaonline.org/volume79/number8/pxc3891600.pdf</ref>

График построен для экспериментальной версии алгоритма для малого числа потоков.

===Динамические характеристики и эффективность реализации алгоритма===
===Выводы для классов архитектур===
===Существующие реализации алгоритма===
Одна из последовательных реализаций алгоритма находится по ссылке [http://codeforge.com/article/192925]

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

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

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

2017-01-26T11:46:33Z

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

{{В инкубаторе}}
== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===
Алгоритм CHAMELEON - алгоритм динамической иерархической кластеризации графа.
<ref name="studo">http://studopedia.ru/7_41934_algoritm-dinamicheskoy-ierarhicheskoy-klasterizatsii-CHAMELEON.html</ref>
Кластеризация - разбиение графа на несколько подграфов таким образом, чтобы объекты внутри одного кластера были максимально близки (схожи), а данные двух различных кластеров максимально различались. Различие и схожесть объектов определяются некоей метрикой, известной заранее. Количество кластеров, на которые будет разбит граф, заранее неизвестно, и зависит от свойств объекта и выбранной метрики. Простейшей возможной метриков является расстояние между точками (если предполагать, что у каждой вершины графа есть координаты).

Алгоритм состоит из 3-х основных этапов:

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

2-й этап заключается в разбиении построенного графа на небольшие кластеры (связные подграфы)

3-й этап состоит в формировании итогового множества кластеров

=== Математическое описание алгоритма ===
'''Исходные данные'''

Множество из n объектов и заданные расстояния между объектами. Эта информация позволяет построить матрицу смежности, в которой будут указаны расстояния между соответствующими объектами по некой метрике. Матрица смежности симметрична, на главной диагонали стоят 0, поэтому достаточно хранить <math>\frac{n(n-1)}{2}</math> элементов. Кроме того задаются параметры, влияющие на работу алгоритма - число k, по которому на первом этапе строится граф по принципу k ближайших соседей, и два параметра <math>{T_{ri}}</math> и <math>{T_{rc}}</math>, используемые на третьем этапе для того, что определить, что не нужно далее продолжать кластеризацию.

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

На первом этапе строится граф <math>G(V,E)</math>, <math>V</math> - множество вершин, <math>E</math> - множество ребер, по принципу k ближайших соседей. Изначально граф состоит из множества вершин и пустого множества ребер. Для каждой вершины графа мы выбираем k других вершин, расстояния до которых минимальны (то есть k первых вершин в списке вершин графа, упорядоченных по увеличению расстояния до данной) и добавляем в множество ребер соответствующие ребра, соединяющие данную вершину с каждой из выбранных k вершин.

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

Состоит в итеративном разбиении графа на множество подграфов. Изначально (на первой итерации) разбиение состоит из единственного подграфа. Пусть <math>T</math> - множество подграфов на текущей итерации. Каждая итерация выполняется следующим образом - выбирается максимальный подграф из имеющихся в разбиении по числу вершин (то есть такой подграф <math>G_1(V_1,E_1)\in{T}: \forall {G_2(V_2,E_2)\in{T}: G_2\neq G_1} => |(V_1)|>|(V_2)|</math> ). Выбранный подграф разбивается на 2 подграфа следующим образом - сначала выбираются все разбиения <math>G_2(V_2,E_2)</math> и <math>G_3(V_3,E_3)</math>, такие, что <math>\min(|V_2|,|V_3|)\geq\frac{|V_1|}{4}</math>. Далее среди всех таких разбиений выбирается такое, для которого величина <math>\sum{|E_1^*|},E_1^* </math>- некое ребро, ведущее из вершины, попавшей в <math>G_2</math> в вершину, попавшую в <math>G_3</math>. В определенный момент, когда размер наибольшего кластера <math>|V_b|\leq{q*|V|}</math>, где <math>|V|</math> - количество вершин в изначальном графе, а <math>q</math> - предварительно заданный параметр, процесс дальнейшего разибения прекращается и алгоритм переходи на 3-й этап

'''Третий этап алгоритма:'''

Введем несколько определений:

Абсолютной взаимной связностью пары кластеров называется величина <math>EC_{({C_i},{C_j})}</math>, вычисляется как сумма весов ребер, соединяющих вершина 1-го кластера <math>C_i</math> с вершинами второго кластера <math>C_j</math>. Внутренняя связность кластера <math>E_{C_i}</math>вычисляется как сумма весов ребер, входящих в разделитель, разбивающих <math>C_i</math> на 2 равных подграфа.

Относительная взаимная связность пары кластеров <math>RI_{(C_i,C_j)}</math> вычисляется по формуле <math>RI_{(C_i,C_j)}=\frac{2*|EC_{(C_i,C_j)}|}{|EC_{C_i}|+|EC_{C_j}|}</math>

Абсолютное взаимное сходство пары кластеров <math>S_{E_{(C_i,C_j)}}</math>вычисляется как среднее сходство между связанными вершинами <math>C_i</math> и <math>C_j</math>

Относительное взаимное сходство пары кластеров <math>C_i</math> и <math>C_j</math> обозначается <math>RC_{(C_i,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_j|}{|C_i|+|C_j|}*S_{EC_{(C_j)}}}}</math>

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

Есть два различных подхода анализа сходства.

Первый - для каждой пары кластеров проверяется истинность следующих высказываний

<math>RI(Ci,Cj)\geq{T_{RI}} </math> и <math>RC_{(C_{i},C_{j})}\geq{T_{RC}}</math>

В случае, если для некоторого <math>C_i</math> существует несколько кластеров <math>C_j</math>, удовлетворяющих этим условиям, выбирается такой <math>C_j</math>, что

значение <math>EC_{(C_i,C_j)}</math> максимально.

Процесс останавливается, когда нет кластеров, удовлетворяющих указанным условиям (либо когда остался только 1 кластер)

Второй подход - выбирается такая пара кластеров, что <math>RI_{(C_i,C_j)}*RC^\alpha_{(C_i,C_j)}</math> максимально, где <math>\alpha</math> - заданный заранее параметр.

Процесс останавливается, когда нет кластеров, удовлетворяющих указанным условиям (либо когда остался только 1 кластер)
<ref name="chamel">http://www-users.cs.umn.edu/~han/dmclass/chameleon.pdf</ref>

=== Вычислительное ядро алгоритма ===
На первом этапе вычислительное ядро состоит из построения графа k ближайших соседей по исходной матрице смежности (требуется для каждой вершины перебрать всех соседей и выделить k ближайших)

На втором этапе вычислительное ядро состоит из повторяющегося нахождения разбиения графа на два подграфа, удовлетворяющего ранее описанным условиям

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

=== Макроструктура алгоритма ===
В рамках первого этапа макрооперацияй считается построение графа k-ближайших соседей

В рамках второго этапа макрооперациями считаются операции разбиения подграфа.

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

=== Схема реализации последовательного алгоритма ===
Схема представлена в виде C++-подобного псевдокода, макрооперации в алгоритме выделены в соответствии с предыдущим разделом описания.
int n; // Количество точек.
int k; // Параметр k
int Dist[n][n]; // Матрица расстояний между точками.

integer E[n][n]; // Матрица рёбер графа

foreach (int i=0; i<n; i++) ) {
integer KNeighbours[k]; // список, используемый для хранения ближайших соседей
integer countN = 0;

foreach (int j=i+1; j<n; j++ ) {
//Заполняем список k ближайших соседей по матрице Dist
}

foreach (int j=0; j<k; j++) {
E[i][KNeighbours[j]] = 1;
}
}
return E;

double q; //Параметр, описание находится в соответствующем разделе.
Graph g = getBiggestGraph(); //Находим граф максимального размера
int maxSize = getSize(g); //Находим размер данного графа
while (maxSize > n * q) {
breakGraph(g); // Разбиваем граф
}

Graph graphs[m]; //Разбиение по кластерам
while (count(graphs)>1){
pairs_exist = false //Значение будет обновлено позже, если найдется подходящая пара для объединения
for (int i = 0; i < m; i++) {
for (int j = i + 1; j < m; j++) {
if (checkSimilarity(graphs[i],graphs[j])) { //Проверяем, достаточно ли схожи графы для объединения
unite(graphs[i], graphs[l])
} else {
break;
}
}
}
}

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

На втором этапе для итеративного разбиения требуется <math>O(nm)</math>операций, где <math>n</math> - количество вершин графа, а <math>m</math> - количество подграфов в итоговом разбиении.

На третьем этапе требуется <math>O(m^2logm)</math> операций, причем вычисление метрики считается за одну операцию.

Итоговая оценка последовательной сложности <math>O(n^2)+O(nm)+O(m^2logm)</math>

=== Информационный граф ===
[[Файл:Инфограф.png]]

=== Ресурс параллелизма алгоритма ===
На первом этапе вычисление <math>k</math> ближайших вершин для <math>i</math>-й вершины можно распараллелить между <math>n</math> процессами (это вычисление независимо для каждой вершины).
На втором и третьем этапах процессы разбиения и объединения подграфов происходят последовательно.
Получаем оценку параллельной сложности алгоритма <math>O(nm)+O(m^2logm)</math>

=== Входные и выходные данные алгоритма ===
На вход алгоритму подается множество из <math>n</math> векторов длины <math>l</math>, описывающих объекты для кластеризации.
Также передаются параметры <math>k</math> (для построения графа k ближайших соседей на первом этапе) и <math>q</math> (используется на втором этапе для определения критерия прекращения итерационного процесса).
На выходе алгоритм выдает массив длины <math>n</math>, заполненный числами от <math>1</math> до <math>n</math>, показывающими, в какой кластер попал соответствующий объект.

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

Вычислительная мощность (соотношение времени выполнения и объема входных и выходных данных) для разных этапов:

<math>O(1)</math> для первого этапа

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

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

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

==Программная реализация алгоритма==
===Особенности реализации последовательного алгоритма===
===Локальность данных и вычислений===
===Возможные способы и особенности параллельной реализации алгоритма===
===Масштабируемость алгоритма и его реализации===
[[Файл:Chameleo.png|300px]]

На приведенном графике видна зависимость эффективности от объема данных и числа процессоров для реализации алгоритма, описанной в <ref name="real">http://research.ijcaonline.org/volume79/number8/pxc3891600.pdf</ref>

График построен для экспериментальной версии алгоритма для малого числа потоков.

===Динамические характеристики и эффективность реализации алгоритма===
===Выводы для классов архитектур===
===Существующие реализации алгоритма===
Одна из последовательных реализаций алгоритма находится по ссылке [http://codeforge.com/article/192925]

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

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

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

2017-01-26T11:46:23Z

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

{{В инкубаторе}}
== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===
Алгоритм CHAMELEON - алгоритм динамической иерархической кластеризации графа.
<ref name="studo">http://studopedia.ru/7_41934_algoritm-dinamicheskoy-ierarhicheskoy-klasterizatsii-CHAMELEON.html</ref>
Кластеризация - разбиение графа на несколько подграфов таким образом, чтобы объекты внутри одного кластера были максимально близки (схожи), а данные двух различных кластеров максимально различались. Различие и схожесть объектов определяются некоей метрикой, известной заранее. Количество кластеров, на которые будет разбит граф, заранее неизвестно, и зависит от свойств объекта и выбранной метрики. Простейшей возможной метриков является расстояние между точками (если предполагать, что у каждой вершины графа есть координаты).

Алгоритм состоит из 3-х основных этапов:

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

2-й этап заключается в разбиении построенного графа на небольшие кластеры (связные подграфы)

3-й этап состоит в формировании итогового множества кластеров

=== Математическое описание алгоритма ===
'''Исходные данные'''

Множество из n объектов и заданные расстояния между объектами. Эта информация позволяет построить матрицу смежности, в которой будут указаны расстояния между соответствующими объектами по некой метрике. Матрица смежности симметрична, на главной диагонали стоят 0, поэтому достаточно хранить <math>\frac{n(n-1)}{2}</math> элементов. Кроме того задаются параметры, влияющие на работу алгоритма - число k, по которому на первом этапе строится граф по принципу k ближайших соседей, и два параметра <math>{T_{ri}}</math> и <math>{T_{rc}}</math>, используемые на третьем этапе для того, что определить, что не нужно далее продолжать кластеризацию.

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

На первом этапе строится граф <math>G(V,E)</math>, <math>V</math> - множество вершин, <math>E</math> - множество ребер, по принципу k ближайших соседей. Изначально граф состоит из множества вершин и пустого множества ребер. Для каждой вершины графа мы выбираем k других вершин, расстояния до которых минимальны (то есть k первых вершин в списке вершин графа, упорядоченных по увеличению расстояния до данной) и добавляем в множество ребер соответствующие ребра, соединяющие данную вершину с каждой из выбранных k вершин.

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

Состоит в итеративном разбиении графа на множество подграфов. Изначально (на первой итерации) разбиение состоит из единственного подграфа. Пусть <math>T</math> - множество подграфов на текущей итерации. Каждая итерация выполняется следующим образом - выбирается максимальный подграф из имеющихся в разбиении по числу вершин (то есть такой подграф <math>G_1(V_1,E_1)\in{T}: \forall {G_2(V_2,E_2)\in{T}: G_2\neq G_1} => |(V_1)|>|(V_2)|</math> ). Выбранный подграф разбивается на 2 подграфа следующим образом - сначала выбираются все разбиения <math>G_2(V_2,E_2)</math> и <math>G_3(V_3,E_3)</math>, такие, что <math>\min(|V_2|,|V_3|)\geq\frac{|V_1|}{4}</math>. Далее среди всех таких разбиений выбирается такое, для которого величина <math>\sum{|E_1^*|},E_1^* </math>- некое ребро, ведущее из вершины, попавшей в <math>G_2</math> в вершину, попавшую в <math>G_3</math>. В определенный момент, когда размер наибольшего кластера <math>|V_b|\leq{q*|V|}</math>, где <math>|V|</math> - количество вершин в изначальном графе, а <math>q</math> - предварительно заданный параметр, процесс дальнейшего разибения прекращается и алгоритм переходи на 3-й этап

'''Третий этап алгоритма:'''

Введем несколько определений:

Абсолютной взаимной связностью пары кластеров называется величина <math>EC_{({C_i},{C_j})}</math>, вычисляется как сумма весов ребер, соединяющих вершина 1-го кластера <math>C_i</math> с вершинами второго кластера <math>C_j</math>. Внутренняя связность кластера <math>E_{C_i}</math>вычисляется как сумма весов ребер, входящих в разделитель, разбивающих <math>C_i</math> на 2 равных подграфа.

Относительная взаимная связность пары кластеров <math>RI_{(C_i,C_j)}</math> вычисляется по формуле <math>RI_{(C_i,C_j)}=\frac{2*|EC_{(C_i,C_j)}|}{|EC_{C_i}|+|EC_{C_j}|}</math>

Абсолютное взаимное сходство пары кластеров <math>S_{E_{(C_i,C_j)}}</math>вычисляется как среднее сходство между связанными вершинами <math>C_i</math> и <math>C_j</math>

Относительное взаимное сходство пары кластеров <math>C_i</math> и <math>C_j</math> обозначается <math>RC_{(C_i,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_j|}{|C_i|+|C_j|}*S_{EC_{(C_j)}}}}</math>

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

Есть два различных подхода анализа сходства.

Первый - для каждой пары кластеров проверяется истинность следующих высказываний

<math>RI(Ci,Cj)\geq{T_{RI}} </math> и <math>RC_{(C_{i},C_{j})}\geq{T_{RC}}</math>

В случае, если для некоторого <math>C_i</math> существует несколько кластеров <math>C_j</math>, удовлетворяющих этим условиям, выбирается такой <math>C_j</math>, что

значение <math>EC_{(C_i,C_j)}</math> максимально.

Процесс останавливается, когда нет кластеров, удовлетворяющих указанным условиям (либо когда остался только 1 кластер)

Второй подход - выбирается такая пара кластеров, что <math>RI_{(C_i,C_j)}*RC^\alpha_{(C_i,C_j)}</math> максимально, где <math>\alpha</math> - заданный заранее параметр.

Процесс останавливается, когда нет кластеров, удовлетворяющих указанным условиям (либо когда остался только 1 кластер)
<ref name="chamel">http://www-users.cs.umn.edu/~han/dmclass/chameleon.pdf</ref>

=== Вычислительное ядро алгоритма ===
На первом этапе вычислительное ядро состоит из построения графа k ближайших соседей по исходной матрице смежности (требуется для каждой вершины перебрать всех соседей и выделить k ближайших)

На втором этапе вычислительное ядро состоит из повторяющегося нахождения разбиения графа на два подграфа, удовлетворяющего ранее описанным условиям

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

=== Макроструктура алгоритма ===
В рамках первого этапа макрооперацияй считается построение графа k-ближайших соседей

В рамках второго этапа макрооперациями считаются операции разбиения подграфа.

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

=== Схема реализации последовательного алгоритма ===
Схема представлена в виде C++-подобного псевдокода, макрооперации в алгоритме выделены в соответствии с предыдущим разделом описания.
int n; // Количество точек.
int k; // Параметр k
int Dist[n][n]; // Матрица расстояний между точками.

integer E[n][n]; // Матрица рёбер графа

foreach (int i=0; i<n; i++) ) {
integer KNeighbours[k]; // список, используемый для хранения ближайших соседей
integer countN = 0;

foreach (int j=i+1; j<n; j++ ) {
//Заполняем список k ближайших соседей по матрице Dist
}

foreach (int j=0; j<k; j++) {
E[i][KNeighbours[j]] = 1;
}
}
return E;

double q; //Параметр, описание находится в соответствующем разделе.
Graph g = getBiggestGraph(); //Находим граф максимального размера
int maxSize = getSize(g); //Находим размер данного графа
while (maxSize > n * q) {
breakGraph(g); // Разбиваем граф
}

Graph graphs[m]; //Разбиение по кластерам
while (count(graphs)>1){
pairs_exist = false //Значение будет обновлено позже, если найдется подходящая пара для объединения
for (int i = 0; i < m; i++) {
for (int j = i + 1; j < m; j++) {
if (checkSimilarity(graphs[i],graphs[j])) { //Проверяем, достаточно ли схожи графы для объединения
unite(graphs[i], graphs[l])
} else {
break;
}
}
}
}

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

На втором этапе для итеративного разбиения требуется <math>O(nm)</math>операций, где <math>n</math> - количество вершин графа, а <math>m</math> - количество подграфов в итоговом разбиении.

На третьем этапе требуется <math>O(m^2logm)</math> операций, причем вычисление метрики считается за одну операцию.

Итоговая оценка последовательной сложности <math>O(n^2)+O(nm)+O(m^2logm)</math>

=== Информационный граф ===
[[Файл:Инфограф.png]]

=== Ресурс параллелизма алгоритма ===
На первом этапе вычисление <math>k</math> ближайших вершин для <math>i</math>-й вершины можно распараллелить между <math>n</math> процессами (это вычисление независимо для каждой вершины).
На втором и третьем этапах процессы разбиения и объединения подграфов происходят последовательно.
Получаем оценку параллельной сложности алгоритма <math>O(nm)+O(m^2logm)</math>

=== Входные и выходные данные алгоритма ===
На вход алгоритму подается множество из <math>n</math> векторов длины <math>l</math>, описывающих объекты для кластеризации.
Также передаются параметры <math>k</math> (для построения графа k ближайших соседей на первом этапе) и <math>q</math> (используется на втором этапе для определения критерия прекращения итерационного процесса).
На выходе алгоритм выдает массив длины <math>n</math>, заполненный числами от <math>1</math> до <math>n</math>, показывающими, в какой кластер попал соответствующий объект.

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

Вычислительная мощность (соотношение времени выполнения и объема входных и выходных данных) для разных этапов:

<math>O(1)</math> для первого этапа

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

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

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

==Программная реализация алгоритма==
===Особенности реализации последовательного алгоритма===
===Локальность данных и вычислений===
===Возможные способы и особенности параллельной реализации алгоритма===
===Масштабируемость алгоритма и его реализации===
[[Файл:Chameleo.png|300px]]

На приведенном графике видна зависимость эффективности от объема данных и числа процессоров для реализации алгоритма, описанной в <ref name="real">http://research.ijcaonline.org/volume79/number8/pxc3891600.pdf</ref>

График построен для экспериментальной версии алгоритма для малого числа потоков.

===Динамические характеристики и эффективность реализации алгоритма===
===Выводы для классов архитектур===
===Существующие реализации алгоритма===
Одна из последовательных реализаций алгоритма находится по ссылке [http://codeforge.com/article/192925]
Параллельных реализаций алгоритма найдено не было
==Литература==

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

2017-01-26T11:46:04Z

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

{{В инкубаторе}}
== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===
Алгоритм CHAMELEON - алгоритм динамической иерархической кластеризации графа.
<ref name="studo">http://studopedia.ru/7_41934_algoritm-dinamicheskoy-ierarhicheskoy-klasterizatsii-CHAMELEON.html</ref>
Кластеризация - разбиение графа на несколько подграфов таким образом, чтобы объекты внутри одного кластера были максимально близки (схожи), а данные двух различных кластеров максимально различались. Различие и схожесть объектов определяются некоей метрикой, известной заранее. Количество кластеров, на которые будет разбит граф, заранее неизвестно, и зависит от свойств объекта и выбранной метрики. Простейшей возможной метриков является расстояние между точками (если предполагать, что у каждой вершины графа есть координаты).

Алгоритм состоит из 3-х основных этапов:

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

2-й этап заключается в разбиении построенного графа на небольшие кластеры (связные подграфы)

3-й этап состоит в формировании итогового множества кластеров

=== Математическое описание алгоритма ===
'''Исходные данные'''

Множество из n объектов и заданные расстояния между объектами. Эта информация позволяет построить матрицу смежности, в которой будут указаны расстояния между соответствующими объектами по некой метрике. Матрица смежности симметрична, на главной диагонали стоят 0, поэтому достаточно хранить <math>\frac{n(n-1)}{2}</math> элементов. Кроме того задаются параметры, влияющие на работу алгоритма - число k, по которому на первом этапе строится граф по принципу k ближайших соседей, и два параметра <math>{T_{ri}}</math> и <math>{T_{rc}}</math>, используемые на третьем этапе для того, что определить, что не нужно далее продолжать кластеризацию.

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

На первом этапе строится граф <math>G(V,E)</math>, <math>V</math> - множество вершин, <math>E</math> - множество ребер, по принципу k ближайших соседей. Изначально граф состоит из множества вершин и пустого множества ребер. Для каждой вершины графа мы выбираем k других вершин, расстояния до которых минимальны (то есть k первых вершин в списке вершин графа, упорядоченных по увеличению расстояния до данной) и добавляем в множество ребер соответствующие ребра, соединяющие данную вершину с каждой из выбранных k вершин.

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

Состоит в итеративном разбиении графа на множество подграфов. Изначально (на первой итерации) разбиение состоит из единственного подграфа. Пусть <math>T</math> - множество подграфов на текущей итерации. Каждая итерация выполняется следующим образом - выбирается максимальный подграф из имеющихся в разбиении по числу вершин (то есть такой подграф <math>G_1(V_1,E_1)\in{T}: \forall {G_2(V_2,E_2)\in{T}: G_2\neq G_1} => |(V_1)|>|(V_2)|</math> ). Выбранный подграф разбивается на 2 подграфа следующим образом - сначала выбираются все разбиения <math>G_2(V_2,E_2)</math> и <math>G_3(V_3,E_3)</math>, такие, что <math>\min(|V_2|,|V_3|)\geq\frac{|V_1|}{4}</math>. Далее среди всех таких разбиений выбирается такое, для которого величина <math>\sum{|E_1^*|},E_1^* </math>- некое ребро, ведущее из вершины, попавшей в <math>G_2</math> в вершину, попавшую в <math>G_3</math>. В определенный момент, когда размер наибольшего кластера <math>|V_b|\leq{q*|V|}</math>, где <math>|V|</math> - количество вершин в изначальном графе, а <math>q</math> - предварительно заданный параметр, процесс дальнейшего разибения прекращается и алгоритм переходи на 3-й этап

'''Третий этап алгоритма:'''

Введем несколько определений:

Абсолютной взаимной связностью пары кластеров называется величина <math>EC_{({C_i},{C_j})}</math>, вычисляется как сумма весов ребер, соединяющих вершина 1-го кластера <math>C_i</math> с вершинами второго кластера <math>C_j</math>. Внутренняя связность кластера <math>E_{C_i}</math>вычисляется как сумма весов ребер, входящих в разделитель, разбивающих <math>C_i</math> на 2 равных подграфа.

Относительная взаимная связность пары кластеров <math>RI_{(C_i,C_j)}</math> вычисляется по формуле <math>RI_{(C_i,C_j)}=\frac{2*|EC_{(C_i,C_j)}|}{|EC_{C_i}|+|EC_{C_j}|}</math>

Абсолютное взаимное сходство пары кластеров <math>S_{E_{(C_i,C_j)}}</math>вычисляется как среднее сходство между связанными вершинами <math>C_i</math> и <math>C_j</math>

Относительное взаимное сходство пары кластеров <math>C_i</math> и <math>C_j</math> обозначается <math>RC_{(C_i,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_j|}{|C_i|+|C_j|}*S_{EC_{(C_j)}}}}</math>

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

Есть два различных подхода анализа сходства.

Первый - для каждой пары кластеров проверяется истинность следующих высказываний

<math>RI(Ci,Cj)\geq{T_{RI}} </math> и <math>RC_{(C_{i},C_{j})}\geq{T_{RC}}</math>

В случае, если для некоторого <math>C_i</math> существует несколько кластеров <math>C_j</math>, удовлетворяющих этим условиям, выбирается такой <math>C_j</math>, что

значение <math>EC_{(C_i,C_j)}</math> максимально.

Процесс останавливается, когда нет кластеров, удовлетворяющих указанным условиям (либо когда остался только 1 кластер)

Второй подход - выбирается такая пара кластеров, что <math>RI_{(C_i,C_j)}*RC^\alpha_{(C_i,C_j)}</math> максимально, где <math>\alpha</math> - заданный заранее параметр.

Процесс останавливается, когда нет кластеров, удовлетворяющих указанным условиям (либо когда остался только 1 кластер)
<ref name="chamel">http://www-users.cs.umn.edu/~han/dmclass/chameleon.pdf</ref>

=== Вычислительное ядро алгоритма ===
На первом этапе вычислительное ядро состоит из построения графа k ближайших соседей по исходной матрице смежности (требуется для каждой вершины перебрать всех соседей и выделить k ближайших)

На втором этапе вычислительное ядро состоит из повторяющегося нахождения разбиения графа на два подграфа, удовлетворяющего ранее описанным условиям

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

=== Макроструктура алгоритма ===
В рамках первого этапа макрооперацияй считается построение графа k-ближайших соседей

В рамках второго этапа макрооперациями считаются операции разбиения подграфа.

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

=== Схема реализации последовательного алгоритма ===
Схема представлена в виде C++-подобного псевдокода, макрооперации в алгоритме выделены в соответствии с предыдущим разделом описания.
int n; // Количество точек.
int k; // Параметр k
int Dist[n][n]; // Матрица расстояний между точками.

integer E[n][n]; // Матрица рёбер графа

foreach (int i=0; i<n; i++) ) {
integer KNeighbours[k]; // список, используемый для хранения ближайших соседей
integer countN = 0;

foreach (int j=i+1; j<n; j++ ) {
//Заполняем список k ближайших соседей по матрице Dist
}

foreach (int j=0; j<k; j++) {
E[i][KNeighbours[j]] = 1;
}
}
return E;

double q; //Параметр, описание находится в соответствующем разделе.
Graph g = getBiggestGraph(); //Находим граф максимального размера
int maxSize = getSize(g); //Находим размер данного графа
while (maxSize > n * q) {
breakGraph(g); // Разбиваем граф
}

Graph graphs[m]; //Разбиение по кластерам
while (count(graphs)>1){
pairs_exist = false //Значение будет обновлено позже, если найдется подходящая пара для объединения
for (int i = 0; i < m; i++) {
for (int j = i + 1; j < m; j++) {
if (checkSimilarity(graphs[i],graphs[j])) { //Проверяем, достаточно ли схожи графы для объединения
unite(graphs[i], graphs[l])
} else {
break;
}
}
}
}

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

На втором этапе для итеративного разбиения требуется <math>O(nm)</math>операций, где <math>n</math> - количество вершин графа, а <math>m</math> - количество подграфов в итоговом разбиении.

На третьем этапе требуется <math>O(m^2logm)</math> операций, причем вычисление метрики считается за одну операцию.

Итоговая оценка последовательной сложности <math>O(n^2)+O(nm)+O(m^2logm)</math>

=== Информационный граф ===
[[Файл:Инфограф.png]]

=== Ресурс параллелизма алгоритма ===
На первом этапе вычисление <math>k</math> ближайших вершин для <math>i</math>-й вершины можно распараллелить между <math>n</math> процессами (это вычисление независимо для каждой вершины).
На втором и третьем этапах процессы разбиения и объединения подграфов происходят последовательно.
Получаем оценку параллельной сложности алгоритма <math>O(nm)+O(m^2logm)</math>

=== Входные и выходные данные алгоритма ===
На вход алгоритму подается множество из <math>n</math> векторов длины <math>l</math>, описывающих объекты для кластеризации.
Также передаются параметры <math>k</math> (для построения графа k ближайших соседей на первом этапе) и <math>q</math> (используется на втором этапе для определения критерия прекращения итерационного процесса).
На выходе алгоритм выдает массив длины <math>n</math>, заполненный числами от <math>1</math> до <math>n</math>, показывающими, в какой кластер попал соответствующий объект.

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

Вычислительная мощность (соотношение времени выполнения и объема входных и выходных данных) для разных этапов:

<math>O(1)</math> для первого этапа

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

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

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

==Программная реализация алгоритма==
===Особенности реализации последовательного алгоритма===
===Локальность данных и вычислений===
===Возможные способы и особенности параллельной реализации алгоритма===
===Масштабируемость алгоритма и его реализации===
[[Файл:Chameleo.png|300px]]

На приведенном графике видна зависимость эффективности от объема данных и числа процессоров для реализации алгоритма, описанной в <ref name="real">http://research.ijcaonline.org/volume79/number8/pxc3891600.pdf</ref>
График построен для экспериментальной версии алгоритма для малого числа потоков.

===Динамические характеристики и эффективность реализации алгоритма===
===Выводы для классов архитектур===
===Существующие реализации алгоритма===
Одна из последовательных реализаций алгоритма находится по ссылке [http://codeforge.com/article/192925]
Параллельных реализаций алгоритма найдено не было
==Литература==

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

2017-01-25T13:55:37Z

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

{{В инкубаторе}}
== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===
Алгоритм CHAMELEON - алгоритм динамической иерархической кластеризации графа.
<ref name="studo">http://studopedia.ru/7_41934_algoritm-dinamicheskoy-ierarhicheskoy-klasterizatsii-CHAMELEON.html</ref>
Кластеризация - разбиение графа на несколько подграфов таким образом, чтобы объекты внутри одного кластера были максимально близки (схожи), а данные двух различных кластеров максимально различались. Различие и схожесть объектов определяются некоей метрикой, известной заранее. Количество кластеров, на которые будет разбит граф, заранее неизвестно, и зависит от свойств объекта и выбранной метрики. Простейшей возможной метриков является расстояние между точками (если предполагать, что у каждой вершины графа есть координаты).

Алгоритм состоит из 3-х основных этапов:

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

2-й этап заключается в разбиении построенного графа на небольшие кластеры (связные подграфы)

3-й этап состоит в формировании итогового множества кластеров

=== Математическое описание алгоритма ===
'''Исходные данные'''

Множество из n объектов и заданные расстояния между объектами. Эта информация позволяет построить матрицу смежности, в которой будут указаны расстояния между соответствующими объектами по некой метрике. Матрица смежности симметрична, на главной диагонали стоят 0, поэтому достаточно хранить <math>\frac{n(n-1)}{2}</math> элементов. Кроме того задаются параметры, влияющие на работу алгоритма - число k, по которому на первом этапе строится граф по принципу k ближайших соседей, и два параметра <math>{T_{ri}}</math> и <math>{T_{rc}}</math>, используемые на третьем этапе для того, что определить, что не нужно далее продолжать кластеризацию.

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

На первом этапе строится граф <math>G(V,E)</math>, <math>V</math> - множество вершин, <math>E</math> - множество ребер, по принципу k ближайших соседей. Изначально граф состоит из множества вершин и пустого множества ребер. Для каждой вершины графа мы выбираем k других вершин, расстояния до которых минимальны (то есть k первых вершин в списке вершин графа, упорядоченных по увеличению расстояния до данной) и добавляем в множество ребер соответствующие ребра, соединяющие данную вершину с каждой из выбранных k вершин.

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

Состоит в итеративном разбиении графа на множество подграфов. Изначально (на первой итерации) разбиение состоит из единственного подграфа. Пусть <math>T</math> - множество подграфов на текущей итерации. Каждая итерация выполняется следующим образом - выбирается максимальный подграф из имеющихся в разбиении по числу вершин (то есть такой подграф <math>G_1(V_1,E_1)\in{T}: \forall {G_2(V_2,E_2)\in{T}: G_2\neq G_1} => |(V_1)|>|(V_2)|</math> ). Выбранный подграф разбивается на 2 подграфа следующим образом - сначала выбираются все разбиения <math>G_2(V_2,E_2)</math> и <math>G_3(V_3,E_3)</math>, такие, что <math>\min(|V_2|,|V_3|)\geq\frac{|V_1|}{4}</math>. Далее среди всех таких разбиений выбирается такое, для которого величина <math>\sum{|E_1^*|},E_1^* </math>- некое ребро, ведущее из вершины, попавшей в <math>G_2</math> в вершину, попавшую в <math>G_3</math>. В определенный момент, когда размер наибольшего кластера <math>|V_b|\leq{q*|V|}</math>, где <math>|V|</math> - количество вершин в изначальном графе, а <math>q</math> - предварительно заданный параметр, процесс дальнейшего разибения прекращается и алгоритм переходи на 3-й этап

'''Третий этап алгоритма:'''

Введем несколько определений:

Абсолютной взаимной связностью пары кластеров называется величина <math>EC_{({C_i},{C_j})}</math>, вычисляется как сумма весов ребер, соединяющих вершина 1-го кластера <math>C_i</math> с вершинами второго кластера <math>C_j</math>. Внутренняя связность кластера <math>E_{C_i}</math>вычисляется как сумма весов ребер, входящих в разделитель, разбивающих <math>C_i</math> на 2 равных подграфа.

Относительная взаимная связность пары кластеров <math>RI_{(C_i,C_j)}</math> вычисляется по формуле <math>RI_{(C_i,C_j)}=\frac{2*|EC_{(C_i,C_j)}|}{|EC_{C_i}|+|EC_{C_j}|}</math>

Абсолютное взаимное сходство пары кластеров <math>S_{E_{(C_i,C_j)}}</math>вычисляется как среднее сходство между связанными вершинами <math>C_i</math> и <math>C_j</math>

Относительное взаимное сходство пары кластеров <math>C_i</math> и <math>C_j</math> обозначается <math>RC_{(C_i,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_j|}{|C_i|+|C_j|}*S_{EC_{(C_j)}}}}</math>

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

Есть два различных подхода анализа сходства.

Первый - для каждой пары кластеров проверяется истинность следующих высказываний

<math>RI(Ci,Cj)\geq{T_{RI}} </math> и <math>RC_{(C_{i},C_{j})}\geq{T_{RC}}</math>

В случае, если для некоторого <math>C_i</math> существует несколько кластеров <math>C_j</math>, удовлетворяющих этим условиям, выбирается такой <math>C_j</math>, что

значение <math>EC_{(C_i,C_j)}</math> максимально.

Процесс останавливается, когда нет кластеров, удовлетворяющих указанным условиям (либо когда остался только 1 кластер)

Второй подход - выбирается такая пара кластеров, что <math>RI_{(C_i,C_j)}*RC^\alpha_{(C_i,C_j)}</math> максимально, где <math>\alpha</math> - заданный заранее параметр.

Процесс останавливается, когда нет кластеров, удовлетворяющих указанным условиям (либо когда остался только 1 кластер)
<ref name="chamel">http://www-users.cs.umn.edu/~han/dmclass/chameleon.pdf</ref>

=== Вычислительное ядро алгоритма ===
На первом этапе вычислительное ядро состоит из построения графа k ближайших соседей по исходной матрице смежности (требуется для каждой вершины перебрать всех соседей и выделить k ближайших)

На втором этапе вычислительное ядро состоит из повторяющегося нахождения разбиения графа на два подграфа, удовлетворяющего ранее описанным условиям

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

=== Макроструктура алгоритма ===
В рамках первого этапа макрооперацияй считается построение графа k-ближайших соседей

В рамках второго этапа макрооперациями считаются операции разбиения подграфа.

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

=== Схема реализации последовательного алгоритма ===
Схема представлена в виде C++-подобного псевдокода, макрооперации в алгоритме выделены в соответствии с предыдущим разделом описания.
int n; // Количество точек.
int k; // Параметр k
int Dist[n][n]; // Матрица расстояний между точками.

integer E[n][n]; // Матрица рёбер графа

foreach (int i=0; i<n; i++) ) {
integer KNeighbours[k]; // список, используемый для хранения ближайших соседей
integer countN = 0;

foreach (int j=i+1; j<n; j++ ) {
//Заполняем список k ближайших соседей по матрице Dist
}

foreach (int j=0; j<k; j++) {
E[i][KNeighbours[j]] = 1;
}
}
return E;

double q; //Параметр, описание находится в соответствующем разделе.
Graph g = getBiggestGraph(); //Находим граф максимального размера
int maxSize = getSize(g); //Находим размер данного графа
while (maxSize > n * q) {
breakGraph(g); // Разбиваем граф
}

Graph graphs[m]; //Разбиение по кластерам
while (count(graphs)>1){
pairs_exist = false //Значение будет обновлено позже, если найдется подходящая пара для объединения
for (int i = 0; i < m; i++) {
for (int j = i + 1; j < m; j++) {
if (checkSimilarity(graphs[i],graphs[j])) { //Проверяем, достаточно ли схожи графы для объединения
unite(graphs[i], graphs[l])
} else {
break;
}
}
}
}

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

На втором этапе для итеративного разбиения требуется <math>O(nm)</math>операций, где <math>n</math> - количество вершин графа, а <math>m</math> - количество подграфов в итоговом разбиении.

На третьем этапе требуется <math>O(m^2logm)</math> операций, причем вычисление метрики считается за одну операцию.

Итоговая оценка последовательной сложности <math>O(n^2)+O(nm)+O(m^2logm)</math>

=== Информационный граф ===
[[Файл:Инфограф.png]]

=== Ресурс параллелизма алгоритма ===
На первом этапе вычисление <math>k</math> ближайших вершин для <math>i</math>-й вершины можно распараллелить между <math>n</math> процессами (это вычисление независимо для каждой вершины).
На втором и третьем этапах процессы разбиения и объединения подграфов происходят последовательно.
Получаем оценку параллельной сложности алгоритма <math>O(nm)+O(m^2logm)</math>

=== Входные и выходные данные алгоритма ===
На вход алгоритму подается множество из <math>n</math> векторов длины <math>l</math>, описывающих объекты для кластеризации.
Также передаются параметры <math>k</math> (для построения графа k ближайших соседей на первом этапе) и <math>q</math> (используется на втором этапе для определения критерия прекращения итерационного процесса).
На выходе алгоритм выдает массив длины <math>n</math>, заполненный числами от <math>1</math> до <math>n</math>, показывающими, в какой кластер попал соответствующий объект.

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

Вычислительная мощность (соотношение времени выполнения и объема входных и выходных данных) для разных этапов:

<math>O(1)</math> для первого этапа

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

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

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

==Программная реализация алгоритма==
===Особенности реализации последовательного алгоритма===
===Локальность данных и вычислений===
===Возможные способы и особенности параллельной реализации алгоритма===
===Масштабируемость алгоритма и его реализации===
[[Файл:Chameleo.png|300px]]

На приведенном графике видна зависимость эффективности от объема данных и числа процессоров для реализации алгоритма, описанной в <ref name="real">http://research.ijcaonline.org/volume79/number8/pxc3891600.pdf</ref>

===Динамические характеристики и эффективность реализации алгоритма===
===Выводы для классов архитектур===
===Существующие реализации алгоритма===
Одна из последовательных реализаций алгоритма находится по ссылке [http://codeforge.com/article/192925]
Параллельных реализаций алгоритма найдено не было
==Литература==

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

2017-01-25T13:55:16Z

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

{{В инкубаторе}}
== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===
Алгоритм CHAMELEON - алгоритм динамической иерархической кластеризации графа.
<ref name="studo">http://studopedia.ru/7_41934_algoritm-dinamicheskoy-ierarhicheskoy-klasterizatsii-CHAMELEON.html</ref>
Кластеризация - разбиение графа на несколько подграфов таким образом, чтобы объекты внутри одного кластера были максимально близки (схожи), а данные двух различных кластеров максимально различались. Различие и схожесть объектов определяются некоей метрикой, известной заранее. Количество кластеров, на которые будет разбит граф, заранее неизвестно, и зависит от свойств объекта и выбранной метрики. Простейшей возможной метриков является расстояние между точками (если предполагать, что у каждой вершины графа есть координаты).

Алгоритм состоит из 3-х основных этапов:

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

2-й этап заключается в разбиении построенного графа на небольшие кластеры (связные подграфы)

3-й этап состоит в формировании итогового множества кластеров

=== Математическое описание алгоритма ===
'''Исходные данные'''

Множество из n объектов и заданные расстояния между объектами. Эта информация позволяет построить матрицу смежности, в которой будут указаны расстояния между соответствующими объектами по некой метрике. Матрица смежности симметрична, на главной диагонали стоят 0, поэтому достаточно хранить <math>\frac{n(n-1)}{2}</math> элементов. Кроме того задаются параметры, влияющие на работу алгоритма - число k, по которому на первом этапе строится граф по принципу k ближайших соседей, и два параметра <math>{T_{ri}}</math> и <math>{T_{rc}}</math>, используемые на третьем этапе для того, что определить, что не нужно далее продолжать кластеризацию.

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

На первом этапе строится граф <math>G(V,E)</math>, <math>V</math> - множество вершин, <math>E</math> - множество ребер, по принципу k ближайших соседей. Изначально граф состоит из множества вершин и пустого множества ребер. Для каждой вершины графа мы выбираем k других вершин, расстояния до которых минимальны (то есть k первых вершин в списке вершин графа, упорядоченных по увеличению расстояния до данной) и добавляем в множество ребер соответствующие ребра, соединяющие данную вершину с каждой из выбранных k вершин.

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

Состоит в итеративном разбиении графа на множество подграфов. Изначально (на первой итерации) разбиение состоит из единственного подграфа. Пусть <math>T</math> - множество подграфов на текущей итерации. Каждая итерация выполняется следующим образом - выбирается максимальный подграф из имеющихся в разбиении по числу вершин (то есть такой подграф <math>G_1(V_1,E_1)\in{T}: \forall {G_2(V_2,E_2)\in{T}: G_2\neq G_1} => |(V_1)|>|(V_2)|</math> ). Выбранный подграф разбивается на 2 подграфа следующим образом - сначала выбираются все разбиения <math>G_2(V_2,E_2)</math> и <math>G_3(V_3,E_3)</math>, такие, что <math>\min(|V_2|,|V_3|)\geq\frac{|V_1|}{4}</math>. Далее среди всех таких разбиений выбирается такое, для которого величина <math>\sum{|E_1^*|},E_1^* </math>- некое ребро, ведущее из вершины, попавшей в <math>G_2</math> в вершину, попавшую в <math>G_3</math>. В определенный момент, когда размер наибольшего кластера <math>|V_b|\leq{q*|V|}</math>, где <math>|V|</math> - количество вершин в изначальном графе, а <math>q</math> - предварительно заданный параметр, процесс дальнейшего разибения прекращается и алгоритм переходи на 3-й этап

'''Третий этап алгоритма:'''

Введем несколько определений:

Абсолютной взаимной связностью пары кластеров называется величина <math>EC_{({C_i},{C_j})}</math>, вычисляется как сумма весов ребер, соединяющих вершина 1-го кластера <math>C_i</math> с вершинами второго кластера <math>C_j</math>. Внутренняя связность кластера <math>E_{C_i}</math>вычисляется как сумма весов ребер, входящих в разделитель, разбивающих <math>C_i</math> на 2 равных подграфа.

Относительная взаимная связность пары кластеров <math>RI_{(C_i,C_j)}</math> вычисляется по формуле <math>RI_{(C_i,C_j)}=\frac{2*|EC_{(C_i,C_j)}|}{|EC_{C_i}|+|EC_{C_j}|}</math>

Абсолютное взаимное сходство пары кластеров <math>S_{E_{(C_i,C_j)}}</math>вычисляется как среднее сходство между связанными вершинами <math>C_i</math> и <math>C_j</math>

Относительное взаимное сходство пары кластеров <math>C_i</math> и <math>C_j</math> обозначается <math>RC_{(C_i,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_j|}{|C_i|+|C_j|}*S_{EC_{(C_j)}}}}</math>

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

Есть два различных подхода анализа сходства.

Первый - для каждой пары кластеров проверяется истинность следующих высказываний

<math>RI(Ci,Cj)\geq{T_{RI}} </math> и <math>RC_{(C_{i},C_{j})}\geq{T_{RC}}</math>

В случае, если для некоторого <math>C_i</math> существует несколько кластеров <math>C_j</math>, удовлетворяющих этим условиям, выбирается такой <math>C_j</math>, что

значение <math>EC_{(C_i,C_j)}</math> максимально.

Процесс останавливается, когда нет кластеров, удовлетворяющих указанным условиям (либо когда остался только 1 кластер)

Второй подход - выбирается такая пара кластеров, что <math>RI_{(C_i,C_j)}*RC^\alpha_{(C_i,C_j)}</math> максимально, где <math>\alpha</math> - заданный заранее параметр.

Процесс останавливается, когда нет кластеров, удовлетворяющих указанным условиям (либо когда остался только 1 кластер)
<ref name="chamel">http://www-users.cs.umn.edu/~han/dmclass/chameleon.pdf</ref>

=== Вычислительное ядро алгоритма ===
На первом этапе вычислительное ядро состоит из построения графа k ближайших соседей по исходной матрице смежности (требуется для каждой вершины перебрать всех соседей и выделить k ближайших)

На втором этапе вычислительное ядро состоит из повторяющегося нахождения разбиения графа на два подграфа, удовлетворяющего ранее описанным условиям

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

=== Макроструктура алгоритма ===
В рамках первого этапа макрооперацияй считается построение графа k-ближайших соседей

В рамках второго этапа макрооперациями считаются операции разбиения подграфа.

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

=== Схема реализации последовательного алгоритма ===
Схема представлена в виде C++-подобного псевдокода, макрооперации в алгоритме выделены в соответствии с предыдущим разделом описания.
int n; // Количество точек.
int k; // Параметр k
int Dist[n][n]; // Матрица расстояний между точками.

integer E[n][n]; // Матрица рёбер графа

foreach (int i=0; i<n; i++) ) {
integer KNeighbours[k]; // список, используемый для хранения ближайших соседей
integer countN = 0;

foreach (int j=i+1; j<n; j++ ) {
//Заполняем список k ближайших соседей по матрице Dist
}

foreach (int j=0; j<k; j++) {
E[i][KNeighbours[j]] = 1;
}
}
return E;

double q; //Параметр, описание находится в соответствующем разделе.
Graph g = getBiggestGraph(); //Находим граф максимального размера
int maxSize = getSize(g); //Находим размер данного графа
while (maxSize > n * q) {
breakGraph(g); // Разбиваем граф
}

Graph graphs[m]; //Разбиение по кластерам
while (count(graphs)>1){
pairs_exist = false //Значение будет обновлено позже, если найдется подходящая пара для объединения
for (int i = 0; i < m; i++) {
for (int j = i + 1; j < m; j++) {
if (checkSimilarity(graphs[i],graphs[j])) { //Проверяем, достаточно ли схожи графы для объединения
unite(graphs[i], graphs[l])
} else {
break;
}
}
}
}

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

На втором этапе для итеративного разбиения требуется <math>O(nm)</math>операций, где <math>n</math> - количество вершин графа, а <math>m</math> - количество подграфов в итоговом разбиении.

На третьем этапе требуется <math>O(m^2logm)</math> операций, причем вычисление метрики считается за одну операцию.

Итоговая оценка последовательной сложности <math>O(n^2)+O(nm)+O(m^2logm)</math>

=== Информационный граф ===
[[Файл:Инфограф.png]]

=== Ресурс параллелизма алгоритма ===
На первом этапе вычисление <math>k</math> ближайших вершин для <math>i</math>-й вершины можно распараллелить между <math>n</math> процессами (это вычисление независимо для каждой вершины).
На втором и третьем этапах процессы разбиения и объединения подграфов происходят последовательно.
Получаем оценку параллельной сложности алгоритма <math>O(nm)+O(m^2logm)</math>

=== Входные и выходные данные алгоритма ===
На вход алгоритму подается множество из <math>n</math> векторов длины <math>l</math>, описывающих объекты для кластеризации.
Также передаются параметры <math>k</math> (для построения графа k ближайших соседей на первом этапе) и <math>q</math> (используется на втором этапе для определения критерия прекращения итерационного процесса).
На выходе алгоритм выдает массив длины <math>n</math>, заполненный числами от <math>1</math> до <math>n</math>, показывающими, в какой кластер попал соответствующий объект.

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

Вычислительная мощность (соотношение времени выполнения и объема входных и выходных данных) для разных этапов:

<math>O(1)</math> для первого этапа

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

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

1-й этап алгоритма детерминирован (граф k ближайших соседей всегда одинаков), второй и третий этапы недетерминированы (зависят от того, какие подграфы будут выбираться на итерациях алгоритма)

==Программная реализация алгоритма==
===Особенности реализации последовательного алгоритма===
===Локальность данных и вычислений===
===Возможные способы и особенности параллельной реализации алгоритма===
===Масштабируемость алгоритма и его реализации===
[[Файл:Chameleo.png|300px]]

На приведенном графике видна зависимость эффективности от объема данных и числа процессоров для реализации алгоритма, описанной в <ref name="real">http://research.ijcaonline.org/volume79/number8/pxc3891600.pdf</ref>

===Динамические характеристики и эффективность реализации алгоритма===
===Выводы для классов архитектур===
===Существующие реализации алгоритма===
Одна из последовательных реализаций алгоритма находится по ссылке [http://codeforge.com/article/192925]
Параллельных реализаций алгоритма найдено не было
==Литература==

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

2017-01-25T13:55:02Z

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

{{В инкубаторе}}
== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===
Алгоритм CHAMELEON - алгоритм динамической иерархической кластеризации графа.
<ref name="studo">http://studopedia.ru/7_41934_algoritm-dinamicheskoy-ierarhicheskoy-klasterizatsii-CHAMELEON.html</ref>
Кластеризация - разбиение графа на несколько подграфов таким образом, чтобы объекты внутри одного кластера были максимально близки (схожи), а данные двух различных кластеров максимально различались. Различие и схожесть объектов определяются некоей метрикой, известной заранее. Количество кластеров, на которые будет разбит граф, заранее неизвестно, и зависит от свойств объекта и выбранной метрики. Простейшей возможной метриков является расстояние между точками (если предполагать, что у каждой вершины графа есть координаты).

Алгоритм состоит из 3-х основных этапов:

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

2-й этап заключается в разбиении построенного графа на небольшие кластеры (связные подграфы)

3-й этап состоит в формировании итогового множества кластеров

=== Математическое описание алгоритма ===
'''Исходные данные'''

Множество из n объектов и заданные расстояния между объектами. Эта информация позволяет построить матрицу смежности, в которой будут указаны расстояния между соответствующими объектами по некой метрике. Матрица смежности симметрична, на главной диагонали стоят 0, поэтому достаточно хранить <math>\frac{n(n-1)}{2}</math> элементов. Кроме того задаются параметры, влияющие на работу алгоритма - число k, по которому на первом этапе строится граф по принципу k ближайших соседей, и два параметра <math>{T_{ri}}</math> и <math>{T_{rc}}</math>, используемые на третьем этапе для того, что определить, что не нужно далее продолжать кластеризацию.

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

На первом этапе строится граф <math>G(V,E)</math>, <math>V</math> - множество вершин, <math>E</math> - множество ребер, по принципу k ближайших соседей. Изначально граф состоит из множества вершин и пустого множества ребер. Для каждой вершины графа мы выбираем k других вершин, расстояния до которых минимальны (то есть k первых вершин в списке вершин графа, упорядоченных по увеличению расстояния до данной) и добавляем в множество ребер соответствующие ребра, соединяющие данную вершину с каждой из выбранных k вершин.

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

Состоит в итеративном разбиении графа на множество подграфов. Изначально (на первой итерации) разбиение состоит из единственного подграфа. Пусть <math>T</math> - множество подграфов на текущей итерации. Каждая итерация выполняется следующим образом - выбирается максимальный подграф из имеющихся в разбиении по числу вершин (то есть такой подграф <math>G_1(V_1,E_1)\in{T}: \forall {G_2(V_2,E_2)\in{T}: G_2\neq G_1} => |(V_1)|>|(V_2)|</math> ). Выбранный подграф разбивается на 2 подграфа следующим образом - сначала выбираются все разбиения <math>G_2(V_2,E_2)</math> и <math>G_3(V_3,E_3)</math>, такие, что <math>\min(|V_2|,|V_3|)\geq\frac{|V_1|}{4}</math>. Далее среди всех таких разбиений выбирается такое, для которого величина <math>\sum{|E_1^*|},E_1^* </math>- некое ребро, ведущее из вершины, попавшей в <math>G_2</math> в вершину, попавшую в <math>G_3</math>. В определенный момент, когда размер наибольшего кластера <math>|V_b|\leq{q*|V|}</math>, где <math>|V|</math> - количество вершин в изначальном графе, а <math>q</math> - предварительно заданный параметр, процесс дальнейшего разибения прекращается и алгоритм переходи на 3-й этап

'''Третий этап алгоритма:'''

Введем несколько определений:

Абсолютной взаимной связностью пары кластеров называется величина <math>EC_{({C_i},{C_j})}</math>, вычисляется как сумма весов ребер, соединяющих вершина 1-го кластера <math>C_i</math> с вершинами второго кластера <math>C_j</math>. Внутренняя связность кластера <math>E_{C_i}</math>вычисляется как сумма весов ребер, входящих в разделитель, разбивающих <math>C_i</math> на 2 равных подграфа.

Относительная взаимная связность пары кластеров <math>RI_{(C_i,C_j)}</math> вычисляется по формуле <math>RI_{(C_i,C_j)}=\frac{2*|EC_{(C_i,C_j)}|}{|EC_{C_i}|+|EC_{C_j}|}</math>

Абсолютное взаимное сходство пары кластеров <math>S_{E_{(C_i,C_j)}}</math>вычисляется как среднее сходство между связанными вершинами <math>C_i</math> и <math>C_j</math>

Относительное взаимное сходство пары кластеров <math>C_i</math> и <math>C_j</math> обозначается <math>RC_{(C_i,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_j|}{|C_i|+|C_j|}*S_{EC_{(C_j)}}}}</math>

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

Есть два различных подхода анализа сходства.

Первый - для каждой пары кластеров проверяется истинность следующих высказываний

<math>RI(Ci,Cj)\geq{T_{RI}} </math> и <math>RC_{(C_{i},C_{j})}\geq{T_{RC}}</math>

В случае, если для некоторого <math>C_i</math> существует несколько кластеров <math>C_j</math>, удовлетворяющих этим условиям, выбирается такой <math>C_j</math>, что

значение <math>EC_{(C_i,C_j)}</math> максимально.

Процесс останавливается, когда нет кластеров, удовлетворяющих указанным условиям (либо когда остался только 1 кластер)

Второй подход - выбирается такая пара кластеров, что <math>RI_{(C_i,C_j)}*RC^\alpha_{(C_i,C_j)}</math> максимально, где <math>\alpha</math> - заданный заранее параметр.

Процесс останавливается, когда нет кластеров, удовлетворяющих указанным условиям (либо когда остался только 1 кластер)
<ref name="chamel">http://www-users.cs.umn.edu/~han/dmclass/chameleon.pdf</ref>

=== Вычислительное ядро алгоритма ===
На первом этапе вычислительное ядро состоит из построения графа k ближайших соседей по исходной матрице смежности (требуется для каждой вершины перебрать всех соседей и выделить k ближайших)

На втором этапе вычислительное ядро состоит из повторяющегося нахождения разбиения графа на два подграфа, удовлетворяющего ранее описанным условиям

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

=== Макроструктура алгоритма ===
В рамках первого этапа макрооперацияй считается построение графа k-ближайших соседей

В рамках второго этапа макрооперациями считаются операции разбиения подграфа.

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

=== Схема реализации последовательного алгоритма ===
Схема представлена в виде C++-подобного псевдокода, макрооперации в алгоритме выделены в соответствии с предыдущим разделом описания.
int n; // Количество точек.
int k; // Параметр k
int Dist[n][n]; // Матрица расстояний между точками.

integer E[n][n]; // Матрица рёбер графа

foreach (int i=0; i<n; i++) ) {
integer KNeighbours[k]; // список, используемый для хранения ближайших соседей
integer countN = 0;

foreach (int j=i+1; j<n; j++ ) {
//Заполняем список k ближайших соседей по матрице Dist
}

foreach (int j=0; j<k; j++) {
E[i][KNeighbours[j]] = 1;
}
}
return E;

double q; //Параметр, описание находится в соответствующем разделе.
Graph g = getBiggestGraph(); //Находим граф максимального размера
int maxSize = getSize(g); //Находим размер данного графа
while (maxSize > n * q) {
breakGraph(g); // Разбиваем граф
}

Graph graphs[m]; //Разбиение по кластерам
while (count(graphs)>1){
pairs_exist = false //Значение будет обновлено позже, если найдется подходящая пара для объединения
for (int i = 0; i < m; i++) {
for (int j = i + 1; j < m; j++) {
if (checkSimilarity(graphs[i],graphs[j])) { //Проверяем, достаточно ли схожи графы для объединения
unite(graphs[i], graphs[l])
} else {
break;
}
}
}
}

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

На втором этапе для итеративного разбиения требуется <math>O(nm)</math>операций, где <math>n</math> - количество вершин графа, а <math>m</math> - количество подграфов в итоговом разбиении.

На третьем этапе требуется <math>O(m^2logm)</math> операций, причем вычисление метрики считается за одну операцию.

Итоговая оценка последовательной сложности <math>O(n^2)+O(nm)+O(m^2logm)</math>

=== Информационный граф ===
[[Файл:Инфограф.png]]

=== Ресурс параллелизма алгоритма ===
На первом этапе вычисление <math>k</math> ближайших вершин для <math>i</math>-й вершины можно распараллелить между <math>n</math> процессами (это вычисление независимо для каждой вершины).
На втором и третьем этапах процессы разбиения и объединения подграфов происходят последовательно.
Получаем оценку параллельной сложности алгоритма <math>O(nm)+O(m^2logm)</math>

=== Входные и выходные данные алгоритма ===
На вход алгоритму подается множество из <math>n</math> векторов длины <math>l</math>, описывающих объекты для кластеризации.
Также передаются параметры <math>k</math> (для построения графа k ближайших соседей на первом этапе) и <math>q</math> (используется на втором этапе для определения критерия прекращения итерационного процесса).
На выходе алгоритм выдает массив длины <math>n</math>, заполненный числами от <math>1</math> до <math>n</math>, показывающими, в какой кластер попал соответствующий объект.

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

Вычислительная мощность (соотношение времени выполнения и объема входных и выходных данных) для разных этапов:
<math>O(1)</math> для первого этапа
<math>O(\frac{nm}{n^2+m^2})</math> для второго этапа
<math>O(\frac{m^2log(m)}{m^2+n})</math> для третьего этапа

1-й этап алгоритма детерминирован (граф k ближайших соседей всегда одинаков), второй и третий этапы недетерминированы (зависят от того, какие подграфы будут выбираться на итерациях алгоритма)

==Программная реализация алгоритма==
===Особенности реализации последовательного алгоритма===
===Локальность данных и вычислений===
===Возможные способы и особенности параллельной реализации алгоритма===
===Масштабируемость алгоритма и его реализации===
[[Файл:Chameleo.png|300px]]

На приведенном графике видна зависимость эффективности от объема данных и числа процессоров для реализации алгоритма, описанной в <ref name="real">http://research.ijcaonline.org/volume79/number8/pxc3891600.pdf</ref>

===Динамические характеристики и эффективность реализации алгоритма===
===Выводы для классов архитектур===
===Существующие реализации алгоритма===
Одна из последовательных реализаций алгоритма находится по ссылке [http://codeforge.com/article/192925]
Параллельных реализаций алгоритма найдено не было
==Литература==

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

2017-01-25T13:44:13Z

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

{{В инкубаторе}}
== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===
Алгоритм CHAMELEON - алгоритм динамической иерархической кластеризации графа.
<ref name="studo">http://studopedia.ru/7_41934_algoritm-dinamicheskoy-ierarhicheskoy-klasterizatsii-CHAMELEON.html</ref>
Кластеризация - разбиение графа на несколько подграфов таким образом, чтобы объекты внутри одного кластера были максимально близки (схожи), а данные двух различных кластеров максимально различались. Различие и схожесть объектов определяются некоей метрикой, известной заранее. Количество кластеров, на которые будет разбит граф, заранее неизвестно, и зависит от свойств объекта и выбранной метрики. Простейшей возможной метриков является расстояние между точками (если предполагать, что у каждой вершины графа есть координаты).

Алгоритм состоит из 3-х основных этапов:

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

2-й этап заключается в разбиении построенного графа на небольшие кластеры (связные подграфы)

3-й этап состоит в формировании итогового множества кластеров

=== Математическое описание алгоритма ===
'''Исходные данные'''

Множество из n объектов и заданные расстояния между объектами. Эта информация позволяет построить матрицу смежности, в которой будут указаны расстояния между соответствующими объектами по некой метрике. Матрица смежности симметрична, на главной диагонали стоят 0, поэтому достаточно хранить <math>\frac{n(n-1)}{2}</math> элементов. Кроме того задаются параметры, влияющие на работу алгоритма - число k, по которому на первом этапе строится граф по принципу k ближайших соседей, и два параметра <math>{T_{ri}}</math> и <math>{T_{rc}}</math>, используемые на третьем этапе для того, что определить, что не нужно далее продолжать кластеризацию.

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

На первом этапе строится граф <math>G(V,E)</math>, <math>V</math> - множество вершин, <math>E</math> - множество ребер, по принципу k ближайших соседей. Изначально граф состоит из множества вершин и пустого множества ребер. Для каждой вершины графа мы выбираем k других вершин, расстояния до которых минимальны (то есть k первых вершин в списке вершин графа, упорядоченных по увеличению расстояния до данной) и добавляем в множество ребер соответствующие ребра, соединяющие данную вершину с каждой из выбранных k вершин.

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

Состоит в итеративном разбиении графа на множество подграфов. Изначально (на первой итерации) разбиение состоит из единственного подграфа. Пусть <math>T</math> - множество подграфов на текущей итерации. Каждая итерация выполняется следующим образом - выбирается максимальный подграф из имеющихся в разбиении по числу вершин (то есть такой подграф <math>G_1(V_1,E_1)\in{T}: \forall {G_2(V_2,E_2)\in{T}: G_2\neq G_1} => |(V_1)|>|(V_2)|</math> ). Выбранный подграф разбивается на 2 подграфа следующим образом - сначала выбираются все разбиения <math>G_2(V_2,E_2)</math> и <math>G_3(V_3,E_3)</math>, такие, что <math>\min(|V_2|,|V_3|)\geq\frac{|V_1|}{4}</math>. Далее среди всех таких разбиений выбирается такое, для которого величина <math>\sum{|E_1^*|},E_1^* </math>- некое ребро, ведущее из вершины, попавшей в <math>G_2</math> в вершину, попавшую в <math>G_3</math>. В определенный момент, когда размер наибольшего кластера <math>|V_b|\leq{q*|V|}</math>, где <math>|V|</math> - количество вершин в изначальном графе, а <math>q</math> - предварительно заданный параметр, процесс дальнейшего разибения прекращается и алгоритм переходи на 3-й этап

'''Третий этап алгоритма:'''

Введем несколько определений:

Абсолютной взаимной связностью пары кластеров называется величина <math>EC_{({C_i},{C_j})}</math>, вычисляется как сумма весов ребер, соединяющих вершина 1-го кластера <math>C_i</math> с вершинами второго кластера <math>C_j</math>. Внутренняя связность кластера <math>E_{C_i}</math>вычисляется как сумма весов ребер, входящих в разделитель, разбивающих <math>C_i</math> на 2 равных подграфа.

Относительная взаимная связность пары кластеров <math>RI_{(C_i,C_j)}</math> вычисляется по формуле <math>RI_{(C_i,C_j)}=\frac{2*|EC_{(C_i,C_j)}|}{|EC_{C_i}|+|EC_{C_j}|}</math>

Абсолютное взаимное сходство пары кластеров <math>S_{E_{(C_i,C_j)}}</math>вычисляется как среднее сходство между связанными вершинами <math>C_i</math> и <math>C_j</math>

Относительное взаимное сходство пары кластеров <math>C_i</math> и <math>C_j</math> обозначается <math>RC_{(C_i,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_j|}{|C_i|+|C_j|}*S_{EC_{(C_j)}}}}</math>

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

Есть два различных подхода анализа сходства.

Первый - для каждой пары кластеров проверяется истинность следующих высказываний

<math>RI(Ci,Cj)\geq{T_{RI}} </math> и <math>RC_{(C_{i},C_{j})}\geq{T_{RC}}</math>

В случае, если для некоторого <math>C_i</math> существует несколько кластеров <math>C_j</math>, удовлетворяющих этим условиям, выбирается такой <math>C_j</math>, что

значение <math>EC_{(C_i,C_j)}</math> максимально.

Процесс останавливается, когда нет кластеров, удовлетворяющих указанным условиям (либо когда остался только 1 кластер)

Второй подход - выбирается такая пара кластеров, что <math>RI_{(C_i,C_j)}*RC^\alpha_{(C_i,C_j)}</math> максимально, где <math>\alpha</math> - заданный заранее параметр.

Процесс останавливается, когда нет кластеров, удовлетворяющих указанным условиям (либо когда остался только 1 кластер)
<ref name="chamel">http://www-users.cs.umn.edu/~han/dmclass/chameleon.pdf</ref>

=== Вычислительное ядро алгоритма ===
На первом этапе вычислительное ядро состоит из построения графа k ближайших соседей по исходной матрице смежности (требуется для каждой вершины перебрать всех соседей и выделить k ближайших)

На втором этапе вычислительное ядро состоит из повторяющегося нахождения разбиения графа на два подграфа, удовлетворяющего ранее описанным условиям

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

=== Макроструктура алгоритма ===
В рамках первого этапа макрооперацияй считается построение графа k-ближайших соседей

В рамках второго этапа макрооперациями считаются операции разбиения подграфа.

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

=== Схема реализации последовательного алгоритма ===
Схема представлена в виде C++-подобного псевдокода, макрооперации в алгоритме выделены в соответствии с предыдущим разделом описания.
int n; // Количество точек.
int k; // Параметр k
int Dist[n][n]; // Матрица расстояний между точками.

integer E[n][n]; // Матрица рёбер графа

foreach (int i=0; i<n; i++) ) {
integer KNeighbours[k]; // список, используемый для хранения ближайших соседей
integer countN = 0;

foreach (int j=i+1; j<n; j++ ) {
//Заполняем список k ближайших соседей по матрице Dist
}

foreach (int j=0; j<k; j++) {
E[i][KNeighbours[j]] = 1;
}
}
return E;

double q; //Параметр, описание находится в соответствующем разделе.
Graph g = getBiggestGraph(); //Находим граф максимального размера
int maxSize = getSize(g); //Находим размер данного графа
while (maxSize > n * q) {
breakGraph(g); // Разбиваем граф
}

Graph graphs[m]; //Разбиение по кластерам
while (count(graphs)>1){
pairs_exist = false //Значение будет обновлено позже, если найдется подходящая пара для объединения
for (int i = 0; i < m; i++) {
for (int j = i + 1; j < m; j++) {
if (checkSimilarity(graphs[i],graphs[j])) { //Проверяем, достаточно ли схожи графы для объединения
unite(graphs[i], graphs[l])
} else {
break;
}
}
}
}

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

На втором этапе для итеративного разбиения требуется <math>O(nm)</math>операций, где <math>n</math> - количество вершин графа, а <math>m</math> - количество подграфов в итоговом разбиении.

На третьем этапе требуется <math>O(m^2logm)</math> операций, причем вычисление метрики считается за одну операцию.

Итоговая оценка последовательной сложности <math>O(n^2)+O(nm)+O(m^2logm)</math>

=== Информационный граф ===
[[Файл:Инфограф.png]]

=== Ресурс параллелизма алгоритма ===
На первом этапе вычисление <math>k</math> ближайших вершин для <math>i</math>-й вершины можно распараллелить между <math>n</math> процессами (это вычисление независимо для каждой вершины).
На втором и третьем этапах процессы разбиения и объединения подграфов происходят последовательно.
Получаем оценку параллельной сложности алгоритма <math>O(nm)+O(m^2logm)</math>

=== Входные и выходные данные алгоритма ===
На вход алгоритму подается множество из <math>n</math> векторов длины <math>l</math>, описывающих объекты для кластеризации.
Также передаются параметры <math>k</math> (для построения графа k ближайших соседей на первом этапе) и <math>q</math> (используется на втором этапе для определения критерия прекращения итерационного процесса).
На выходе алгоритм выдает массив длины <math>n</math>, заполненный числами от <math>1</math> до <math>n</math>, показывающими, в какой кластер попал соответствующий объект.

==Программная реализация алгоритма==
===Особенности реализации последовательного алгоритма===
===Локальность данных и вычислений===
===Возможные способы и особенности параллельной реализации алгоритма===
===Масштабируемость алгоритма и его реализации===
[[Файл:Chameleo.png|300px]]

На приведенном графике видна зависимость эффективности от объема данных и числа процессоров для реализации алгоритма, описанной в <ref name="real">http://research.ijcaonline.org/volume79/number8/pxc3891600.pdf</ref>

===Динамические характеристики и эффективность реализации алгоритма===
===Выводы для классов архитектур===
===Существующие реализации алгоритма===
Одна из последовательных реализаций алгоритма находится по ссылке [http://codeforge.com/article/192925]
Параллельных реализаций алгоритма найдено не было
==Литература==

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

2017-01-25T13:41:10Z

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

{{В инкубаторе}}
== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===
Алгоритм CHAMELEON - алгоритм динамической иерархической кластеризации графа.
<ref name="studo">http://studopedia.ru/7_41934_algoritm-dinamicheskoy-ierarhicheskoy-klasterizatsii-CHAMELEON.html</ref>
Кластеризация - разбиение графа на несколько подграфов таким образом, чтобы объекты внутри одного кластера были максимально близки (схожи), а данные двух различных кластеров максимально различались. Различие и схожесть объектов определяются некоей метрикой, известной заранее. Количество кластеров, на которые будет разбит граф, заранее неизвестно, и зависит от свойств объекта и выбранной метрики. Простейшей возможной метриков является расстояние между точками (если предполагать, что у каждой вершины графа есть координаты).

Алгоритм состоит из 3-х основных этапов:

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

2-й этап заключается в разбиении построенного графа на небольшие кластеры (связные подграфы)

3-й этап состоит в формировании итогового множества кластеров

=== Математическое описание алгоритма ===
'''Исходные данные'''

Множество из n объектов и заданные расстояния между объектами. Эта информация позволяет построить матрицу смежности, в которой будут указаны расстояния между соответствующими объектами по некой метрике. Матрица смежности симметрична, на главной диагонали стоят 0, поэтому достаточно хранить <math>\frac{n(n-1)}{2}</math> элементов. Кроме того задаются параметры, влияющие на работу алгоритма - число k, по которому на первом этапе строится граф по принципу k ближайших соседей, и два параметра <math>{T_{ri}}</math> и <math>{T_{rc}}</math>, используемые на третьем этапе для того, что определить, что не нужно далее продолжать кластеризацию.

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

На первом этапе строится граф <math>G(V,E)</math>, <math>V</math> - множество вершин, <math>E</math> - множество ребер, по принципу k ближайших соседей. Изначально граф состоит из множества вершин и пустого множества ребер. Для каждой вершины графа мы выбираем k других вершин, расстояния до которых минимальны (то есть k первых вершин в списке вершин графа, упорядоченных по увеличению расстояния до данной) и добавляем в множество ребер соответствующие ребра, соединяющие данную вершину с каждой из выбранных k вершин.

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

Состоит в итеративном разбиении графа на множество подграфов. Изначально (на первой итерации) разбиение состоит из единственного подграфа. Пусть <math>T</math> - множество подграфов на текущей итерации. Каждая итерация выполняется следующим образом - выбирается максимальный подграф из имеющихся в разбиении по числу вершин (то есть такой подграф <math>G_1(V_1,E_1)\in{T}: \forall {G_2(V_2,E_2)\in{T}: G_2\neq G_1} => |(V_1)|>|(V_2)|</math> ). Выбранный подграф разбивается на 2 подграфа следующим образом - сначала выбираются все разбиения <math>G_2(V_2,E_2)</math> и <math>G_3(V_3,E_3)</math>, такие, что <math>\min(|V_2|,|V_3|)\geq\frac{|V_1|}{4}</math>. Далее среди всех таких разбиений выбирается такое, для которого величина <math>\sum{|E_1^*|},E_1^* </math>- некое ребро, ведущее из вершины, попавшей в <math>G_2</math> в вершину, попавшую в <math>G_3</math>. В определенный момент, когда размер наибольшего кластера <math>|V_b|\leq{q*|V|}</math>, где <math>|V|</math> - количество вершин в изначальном графе, а <math>q</math> - предварительно заданный параметр, процесс дальнейшего разибения прекращается и алгоритм переходи на 3-й этап

'''Третий этап алгоритма:'''

Введем несколько определений:

Абсолютной взаимной связностью пары кластеров называется величина <math>EC_{({C_i},{C_j})}</math>, вычисляется как сумма весов ребер, соединяющих вершина 1-го кластера <math>C_i</math> с вершинами второго кластера <math>C_j</math>. Внутренняя связность кластера <math>E_{C_i}</math>вычисляется как сумма весов ребер, входящих в разделитель, разбивающих <math>C_i</math> на 2 равных подграфа.

Относительная взаимная связность пары кластеров <math>RI_{(C_i,C_j)}</math> вычисляется по формуле <math>RI_{(C_i,C_j)}=\frac{2*|EC_{(C_i,C_j)}|}{|EC_{C_i}|+|EC_{C_j}|}</math>

Абсолютное взаимное сходство пары кластеров <math>S_{E_{(C_i,C_j)}}</math>вычисляется как среднее сходство между связанными вершинами <math>C_i</math> и <math>C_j</math>

Относительное взаимное сходство пары кластеров <math>C_i</math> и <math>C_j</math> обозначается <math>RC_{(C_i,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_j|}{|C_i|+|C_j|}*S_{EC_{(C_j)}}}}</math>

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

Есть два различных подхода анализа сходства.

Первый - для каждой пары кластеров проверяется истинность следующих высказываний

<math>RI(Ci,Cj)\geq{T_{RI}} </math> и <math>RC_{(C_{i},C_{j})}\geq{T_{RC}}</math>

В случае, если для некоторого <math>C_i</math> существует несколько кластеров <math>C_j</math>, удовлетворяющих этим условиям, выбирается такой <math>C_j</math>, что

значение <math>EC_{(C_i,C_j)}</math> максимально.

Процесс останавливается, когда нет кластеров, удовлетворяющих указанным условиям (либо когда остался только 1 кластер)

Второй подход - выбирается такая пара кластеров, что <math>RI_{(C_i,C_j)}*RC^\alpha_{(C_i,C_j)}</math> максимально, где <math>\alpha</math> - заданный заранее параметр.

Процесс останавливается, когда нет кластеров, удовлетворяющих указанным условиям (либо когда остался только 1 кластер)

=== Вычислительное ядро алгоритма ===
На первом этапе вычислительное ядро состоит из построения графа k ближайших соседей по исходной матрице смежности (требуется для каждой вершины перебрать всех соседей и выделить k ближайших)

На втором этапе вычислительное ядро состоит из повторяющегося нахождения разбиения графа на два подграфа, удовлетворяющего ранее описанным условиям

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

=== Макроструктура алгоритма ===
В рамках первого этапа макрооперацияй считается построение графа k-ближайших соседей

В рамках второго этапа макрооперациями считаются операции разбиения подграфа.

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

=== Схема реализации последовательного алгоритма ===
Схема представлена в виде C++-подобного псевдокода, макрооперации в алгоритме выделены в соответствии с предыдущим разделом описания.
int n; // Количество точек.
int k; // Параметр k
int Dist[n][n]; // Матрица расстояний между точками.

integer E[n][n]; // Матрица рёбер графа

foreach (int i=0; i<n; i++) ) {
integer KNeighbours[k]; // список, используемый для хранения ближайших соседей
integer countN = 0;

foreach (int j=i+1; j<n; j++ ) {
//Заполняем список k ближайших соседей по матрице Dist
}

foreach (int j=0; j<k; j++) {
E[i][KNeighbours[j]] = 1;
}
}
return E;

double q; //Параметр, описание находится в соответствующем разделе.
Graph g = getBiggestGraph(); //Находим граф максимального размера
int maxSize = getSize(g); //Находим размер данного графа
while (maxSize > n * q) {
breakGraph(g); // Разбиваем граф
}

Graph graphs[m]; //Разбиение по кластерам
while (count(graphs)>1){
pairs_exist = false //Значение будет обновлено позже, если найдется подходящая пара для объединения
for (int i = 0; i < m; i++) {
for (int j = i + 1; j < m; j++) {
if (checkSimilarity(graphs[i],graphs[j])) { //Проверяем, достаточно ли схожи графы для объединения
unite(graphs[i], graphs[l])
} else {
break;
}
}
}
}

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

На втором этапе для итеративного разбиения требуется <math>O(nm)</math>операций, где <math>n</math> - количество вершин графа, а <math>m</math> - количество подграфов в итоговом разбиении.

На третьем этапе требуется <math>O(m^2logm)</math> операций, причем вычисление метрики считается за одну операцию.

Итоговая оценка последовательной сложности <math>O(n^2)+O(nm)+O(m^2logm)</math>

=== Информационный граф ===
[[Файл:Инфограф.png]]

=== Ресурс параллелизма алгоритма ===
На первом этапе вычисление <math>k</math> ближайших вершин для <math>i</math>-й вершины можно распараллелить между <math>n</math> процессами (это вычисление независимо для каждой вершины).
На втором и третьем этапах процессы разбиения и объединения подграфов происходят последовательно.
Получаем оценку параллельной сложности алгоритма <math>O(nm)+O(m^2logm)</math>

=== Входные и выходные данные алгоритма ===
На вход алгоритму подается множество из <math>n</math> векторов длины <math>l</math>, описывающих объекты для кластеризации.
Также передаются параметры <math>k</math> (для построения графа k ближайших соседей на первом этапе) и <math>q</math> (используется на втором этапе для определения критерия прекращения итерационного процесса).
На выходе алгоритм выдает массив длины <math>n</math>, заполненный числами от <math>1</math> до <math>n</math>, показывающими, в какой кластер попал соответствующий объект.

==Программная реализация алгоритма==
===Особенности реализации последовательного алгоритма===
===Локальность данных и вычислений===
===Возможные способы и особенности параллельной реализации алгоритма===
===Масштабируемость алгоритма и его реализации===
[[Файл:Chameleo.png|300px]]

На приведенном графике видна зависимость эффективности от объема данных и числа процессоров для реализации алгоритма, описанной в <ref name="real">http://research.ijcaonline.org/volume79/number8/pxc3891600.pdf</ref>

===Динамические характеристики и эффективность реализации алгоритма===
===Выводы для классов архитектур===
===Существующие реализации алгоритма===
Одна из последовательных реализаций алгоритма находится по ссылке [http://codeforge.com/article/192925]
Параллельных реализаций алгоритма найдено не было
==Литература==

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

2017-01-25T13:39:47Z

Hromovalexander: /* Программная реализация алгоритма */

{{В инкубаторе}}
== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===
Алгоритм CHAMELEON - алгоритм динамической иерархической кластеризации графа.

Кластеризация - разбиение графа на несколько подграфов таким образом, чтобы объекты внутри одного кластера были максимально близки (схожи), а данные двух различных кластеров максимально различались. Различие и схожесть объектов определяются некоей метрикой, известной заранее. Количество кластеров, на которые будет разбит граф, заранее неизвестно, и зависит от свойств объекта и выбранной метрики. Простейшей возможной метриков является расстояние между точками (если предполагать, что у каждой вершины графа есть координаты).

Алгоритм состоит из 3-х основных этапов:

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

2-й этап заключается в разбиении построенного графа на небольшие кластеры (связные подграфы)

3-й этап состоит в формировании итогового множества кластеров

=== Математическое описание алгоритма ===
'''Исходные данные'''

Множество из n объектов и заданные расстояния между объектами. Эта информация позволяет построить матрицу смежности, в которой будут указаны расстояния между соответствующими объектами по некой метрике. Матрица смежности симметрична, на главной диагонали стоят 0, поэтому достаточно хранить <math>\frac{n(n-1)}{2}</math> элементов. Кроме того задаются параметры, влияющие на работу алгоритма - число k, по которому на первом этапе строится граф по принципу k ближайших соседей, и два параметра <math>{T_{ri}}</math> и <math>{T_{rc}}</math>, используемые на третьем этапе для того, что определить, что не нужно далее продолжать кластеризацию.

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

На первом этапе строится граф <math>G(V,E)</math>, <math>V</math> - множество вершин, <math>E</math> - множество ребер, по принципу k ближайших соседей. Изначально граф состоит из множества вершин и пустого множества ребер. Для каждой вершины графа мы выбираем k других вершин, расстояния до которых минимальны (то есть k первых вершин в списке вершин графа, упорядоченных по увеличению расстояния до данной) и добавляем в множество ребер соответствующие ребра, соединяющие данную вершину с каждой из выбранных k вершин.

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

Состоит в итеративном разбиении графа на множество подграфов. Изначально (на первой итерации) разбиение состоит из единственного подграфа. Пусть <math>T</math> - множество подграфов на текущей итерации. Каждая итерация выполняется следующим образом - выбирается максимальный подграф из имеющихся в разбиении по числу вершин (то есть такой подграф <math>G_1(V_1,E_1)\in{T}: \forall {G_2(V_2,E_2)\in{T}: G_2\neq G_1} => |(V_1)|>|(V_2)|</math> ). Выбранный подграф разбивается на 2 подграфа следующим образом - сначала выбираются все разбиения <math>G_2(V_2,E_2)</math> и <math>G_3(V_3,E_3)</math>, такие, что <math>\min(|V_2|,|V_3|)\geq\frac{|V_1|}{4}</math>. Далее среди всех таких разбиений выбирается такое, для которого величина <math>\sum{|E_1^*|},E_1^* </math>- некое ребро, ведущее из вершины, попавшей в <math>G_2</math> в вершину, попавшую в <math>G_3</math>. В определенный момент, когда размер наибольшего кластера <math>|V_b|\leq{q*|V|}</math>, где <math>|V|</math> - количество вершин в изначальном графе, а <math>q</math> - предварительно заданный параметр, процесс дальнейшего разибения прекращается и алгоритм переходи на 3-й этап

'''Третий этап алгоритма:'''

Введем несколько определений:

Абсолютной взаимной связностью пары кластеров называется величина <math>EC_{({C_i},{C_j})}</math>, вычисляется как сумма весов ребер, соединяющих вершина 1-го кластера <math>C_i</math> с вершинами второго кластера <math>C_j</math>. Внутренняя связность кластера <math>E_{C_i}</math>вычисляется как сумма весов ребер, входящих в разделитель, разбивающих <math>C_i</math> на 2 равных подграфа.

Относительная взаимная связность пары кластеров <math>RI_{(C_i,C_j)}</math> вычисляется по формуле <math>RI_{(C_i,C_j)}=\frac{2*|EC_{(C_i,C_j)}|}{|EC_{C_i}|+|EC_{C_j}|}</math>

Абсолютное взаимное сходство пары кластеров <math>S_{E_{(C_i,C_j)}}</math>вычисляется как среднее сходство между связанными вершинами <math>C_i</math> и <math>C_j</math>

Относительное взаимное сходство пары кластеров <math>C_i</math> и <math>C_j</math> обозначается <math>RC_{(C_i,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_j|}{|C_i|+|C_j|}*S_{EC_{(C_j)}}}}</math>

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

Есть два различных подхода анализа сходства.

Первый - для каждой пары кластеров проверяется истинность следующих высказываний

<math>RI(Ci,Cj)\geq{T_{RI}} </math> и <math>RC_{(C_{i},C_{j})}\geq{T_{RC}}</math>

В случае, если для некоторого <math>C_i</math> существует несколько кластеров <math>C_j</math>, удовлетворяющих этим условиям, выбирается такой <math>C_j</math>, что

значение <math>EC_{(C_i,C_j)}</math> максимально.

Процесс останавливается, когда нет кластеров, удовлетворяющих указанным условиям (либо когда остался только 1 кластер)

Второй подход - выбирается такая пара кластеров, что <math>RI_{(C_i,C_j)}*RC^\alpha_{(C_i,C_j)}</math> максимально, где <math>\alpha</math> - заданный заранее параметр.

Процесс останавливается, когда нет кластеров, удовлетворяющих указанным условиям (либо когда остался только 1 кластер)

=== Вычислительное ядро алгоритма ===
На первом этапе вычислительное ядро состоит из построения графа k ближайших соседей по исходной матрице смежности (требуется для каждой вершины перебрать всех соседей и выделить k ближайших)

На втором этапе вычислительное ядро состоит из повторяющегося нахождения разбиения графа на два подграфа, удовлетворяющего ранее описанным условиям

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

=== Макроструктура алгоритма ===
В рамках первого этапа макрооперацияй считается построение графа k-ближайших соседей

В рамках второго этапа макрооперациями считаются операции разбиения подграфа.

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

=== Схема реализации последовательного алгоритма ===
Схема представлена в виде C++-подобного псевдокода, макрооперации в алгоритме выделены в соответствии с предыдущим разделом описания.
int n; // Количество точек.
int k; // Параметр k
int Dist[n][n]; // Матрица расстояний между точками.

integer E[n][n]; // Матрица рёбер графа

foreach (int i=0; i<n; i++) ) {
integer KNeighbours[k]; // список, используемый для хранения ближайших соседей
integer countN = 0;

foreach (int j=i+1; j<n; j++ ) {
//Заполняем список k ближайших соседей по матрице Dist
}

foreach (int j=0; j<k; j++) {
E[i][KNeighbours[j]] = 1;
}
}
return E;

double q; //Параметр, описание находится в соответствующем разделе.
Graph g = getBiggestGraph(); //Находим граф максимального размера
int maxSize = getSize(g); //Находим размер данного графа
while (maxSize > n * q) {
breakGraph(g); // Разбиваем граф
}

Graph graphs[m]; //Разбиение по кластерам
while (count(graphs)>1){
pairs_exist = false //Значение будет обновлено позже, если найдется подходящая пара для объединения
for (int i = 0; i < m; i++) {
for (int j = i + 1; j < m; j++) {
if (checkSimilarity(graphs[i],graphs[j])) { //Проверяем, достаточно ли схожи графы для объединения
unite(graphs[i], graphs[l])
} else {
break;
}
}
}
}

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

На втором этапе для итеративного разбиения требуется <math>O(nm)</math>операций, где <math>n</math> - количество вершин графа, а <math>m</math> - количество подграфов в итоговом разбиении.

На третьем этапе требуется <math>O(m^2logm)</math> операций, причем вычисление метрики считается за одну операцию.

Итоговая оценка последовательной сложности <math>O(n^2)+O(nm)+O(m^2logm)</math>

=== Информационный граф ===
[[Файл:Инфограф.png]]

=== Ресурс параллелизма алгоритма ===
На первом этапе вычисление <math>k</math> ближайших вершин для <math>i</math>-й вершины можно распараллелить между <math>n</math> процессами (это вычисление независимо для каждой вершины).
На втором и третьем этапах процессы разбиения и объединения подграфов происходят последовательно.
Получаем оценку параллельной сложности алгоритма <math>O(nm)+O(m^2logm)</math>

=== Входные и выходные данные алгоритма ===
На вход алгоритму подается множество из <math>n</math> векторов длины <math>l</math>, описывающих объекты для кластеризации.
Также передаются параметры <math>k</math> (для построения графа k ближайших соседей на первом этапе) и <math>q</math> (используется на втором этапе для определения критерия прекращения итерационного процесса).
На выходе алгоритм выдает массив длины <math>n</math>, заполненный числами от <math>1</math> до <math>n</math>, показывающими, в какой кластер попал соответствующий объект.

==Программная реализация алгоритма==
===Особенности реализации последовательного алгоритма===
===Локальность данных и вычислений===
===Возможные способы и особенности параллельной реализации алгоритма===
===Масштабируемость алгоритма и его реализации===
[[Файл:Chameleo.png|300px]]

На приведенном графике видна зависимость эффективности от объема данных и числа процессоров для реализации алгоритма, описанной в <ref name="real">http://research.ijcaonline.org/volume79/number8/pxc3891600.pdf</ref>

===Динамические характеристики и эффективность реализации алгоритма===
===Выводы для классов архитектур===
===Существующие реализации алгоритма===
Одна из последовательных реализаций алгоритма находится по ссылке [http://codeforge.com/article/192925]
Параллельных реализаций алгоритма найдено не было
==Литература==

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

2017-01-25T13:38:46Z

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

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

2017-01-25T13:33:21Z

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

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

2017-01-25T13:33:13Z

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

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

2017-01-25T13:33:03Z

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

{{В инкубаторе}}
== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===
Алгоритм CHAMELEON - алгоритм динамической иерархической кластеризации графа.

Кластеризация - разбиение графа на несколько подграфов таким образом, чтобы объекты внутри одного кластера были максимально близки (схожи), а данные двух различных кластеров максимально различались. Различие и схожесть объектов определяются некоей метрикой, известной заранее. Количество кластеров, на которые будет разбит граф, заранее неизвестно, и зависит от свойств объекта и выбранной метрики. Простейшей возможной метриков является расстояние между точками (если предполагать, что у каждой вершины графа есть координаты).

Алгоритм состоит из 3-х основных этапов:

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

2-й этап заключается в разбиении построенного графа на небольшие кластеры (связные подграфы)

3-й этап состоит в формировании итогового множества кластеров

=== Математическое описание алгоритма ===
'''Исходные данные'''

Множество из n объектов и заданные расстояния между объектами. Эта информация позволяет построить матрицу смежности, в которой будут указаны расстояния между соответствующими объектами по некой метрике. Матрица смежности симметрична, на главной диагонали стоят 0, поэтому достаточно хранить <math>\frac{n(n-1)}{2}</math> элементов. Кроме того задаются параметры, влияющие на работу алгоритма - число k, по которому на первом этапе строится граф по принципу k ближайших соседей, и два параметра <math>{T_{ri}}</math> и <math>{T_{rc}}</math>, используемые на третьем этапе для того, что определить, что не нужно далее продолжать кластеризацию.

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

На первом этапе строится граф <math>G(V,E)</math>, <math>V</math> - множество вершин, <math>E</math> - множество ребер, по принципу k ближайших соседей. Изначально граф состоит из множества вершин и пустого множества ребер. Для каждой вершины графа мы выбираем k других вершин, расстояния до которых минимальны (то есть k первых вершин в списке вершин графа, упорядоченных по увеличению расстояния до данной) и добавляем в множество ребер соответствующие ребра, соединяющие данную вершину с каждой из выбранных k вершин.

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

Состоит в итеративном разбиении графа на множество подграфов. Изначально (на первой итерации) разбиение состоит из единственного подграфа. Пусть <math>T</math> - множество подграфов на текущей итерации. Каждая итерация выполняется следующим образом - выбирается максимальный подграф из имеющихся в разбиении по числу вершин (то есть такой подграф <math>G_1(V_1,E_1)\in{T}: \forall {G_2(V_2,E_2)\in{T}: G_2\neq G_1} => |(V_1)|>|(V_2)|</math> ). Выбранный подграф разбивается на 2 подграфа следующим образом - сначала выбираются все разбиения <math>G_2(V_2,E_2)</math> и <math>G_3(V_3,E_3)</math>, такие, что <math>\min(|V_2|,|V_3|)\geq\frac{|V_1|}{4}</math>. Далее среди всех таких разбиений выбирается такое, для которого величина <math>\sum{|E_1^*|},E_1^* </math>- некое ребро, ведущее из вершины, попавшей в <math>G_2</math> в вершину, попавшую в <math>G_3</math>. В определенный момент, когда размер наибольшего кластера <math>|V_b|\leq{q*|V|}</math>, где <math>|V|</math> - количество вершин в изначальном графе, а <math>q</math> - предварительно заданный параметр, процесс дальнейшего разибения прекращается и алгоритм переходи на 3-й этап

'''Третий этап алгоритма:'''

Введем несколько определений:

Абсолютной взаимной связностью пары кластеров называется величина <math>EC_{({C_i},{C_j})}</math>, вычисляется как сумма весов ребер, соединяющих вершина 1-го кластера <math>C_i</math> с вершинами второго кластера <math>C_j</math>. Внутренняя связность кластера <math>E_{C_i}</math>вычисляется как сумма весов ребер, входящих в разделитель, разбивающих <math>C_i</math> на 2 равных подграфа.

Относительная взаимная связность пары кластеров <math>RI_{(C_i,C_j)}</math> вычисляется по формуле <math>RI_{(C_i,C_j)}=\frac{2*|EC_{(C_i,C_j)}|}{|EC_{C_i}|+|EC_{C_j}|}</math>

Абсолютное взаимное сходство пары кластеров <math>S_{E_{(C_i,C_j)}}</math>вычисляется как среднее сходство между связанными вершинами <math>C_i</math> и <math>C_j</math>

Относительное взаимное сходство пары кластеров <math>C_i</math> и <math>C_j</math> обозначается <math>RC_{(C_i,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_j|}{|C_i|+|C_j|}*S_{EC_{(C_j)}}}}</math>

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

Есть два различных подхода анализа сходства.

Первый - для каждой пары кластеров проверяется истинность следующих высказываний

<math>RI(Ci,Cj)\geq{T_{RI}} </math> и <math>RC_{(C_{i},C_{j})}\geq{T_{RC}}</math>

В случае, если для некоторого <math>C_i</math> существует несколько кластеров <math>C_j</math>, удовлетворяющих этим условиям, выбирается такой <math>C_j</math>, что

значение <math>EC_{(C_i,C_j)}</math> максимально.

Процесс останавливается, когда нет кластеров, удовлетворяющих указанным условиям (либо когда остался только 1 кластер)

Второй подход - выбирается такая пара кластеров, что <math>RI_{(C_i,C_j)}*RC^\alpha_{(C_i,C_j)}</math> максимально, где <math>\alpha</math> - заданный заранее параметр.

Процесс останавливается, когда нет кластеров, удовлетворяющих указанным условиям (либо когда остался только 1 кластер)

=== Вычислительное ядро алгоритма ===
На первом этапе вычислительное ядро состоит из построения графа k ближайших соседей по исходной матрице смежности (требуется для каждой вершины перебрать всех соседей и выделить k ближайших)

На втором этапе вычислительное ядро состоит из повторяющегося нахождения разбиения графа на два подграфа, удовлетворяющего ранее описанным условиям

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

=== Макроструктура алгоритма ===
В рамках первого этапа макрооперацияй считается построение графа k-ближайших соседей

В рамках второго этапа макрооперациями считаются операции разбиения подграфа.

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

=== Схема реализации последовательного алгоритма ===
Схема представлена в виде C++-подобного псевдокода, макрооперации в алгоритме выделены в соответствии с предыдущим разделом описания.
int n; // Количество точек.
int k; // Параметр k
int Dist[n][n]; // Матрица расстояний между точками.

integer E[n][n]; // Матрица рёбер графа

foreach (int i=0; i<n; i++) ) {
integer KNeighbours[k]; // список, используемый для хранения ближайших соседей
integer countN = 0;

foreach (int j=i+1; j<n; j++ ) {
//Заполняем список k ближайших соседей по матрице Dist
}

foreach (int j=0; j<k; j++) {
E[i][KNeighbours[j]] = 1;
}
}
return E;

double q; //Параметр, описание находится в соответствующем разделе.
Graph g = getBiggestGraph(); //Находим граф максимального размера
int maxSize = getSize(g); //Находим размер данного графа
while (maxSize > n * q) {
breakGraph(g); // Разбиваем граф
}

Graph graphs[m]; //Разбиение по кластерам
while (count(graphs)>1){
pairs_exist = false //Значение будет обновлено позже, если найдется подходящая пара для объединения
for (int i = 0; i < m; i++) {
for (int j = i + 1; j < m; j++) {
if (checkSimilarity(graphs[i],graphs[j])) { //Проверяем, достаточно ли схожи графы для объединения
unite(graphs[i], graphs[l])
} else {
break;
}
}
}
}

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

На втором этапе для итеративного разбиения требуется <math>O(nm)</math>операций, где <math>n</math> - количество вершин графа, а <math>m</math> - количество подграфов в итоговом разбиении.

На третьем этапе требуется <math>O(m^2logm)</math> операций, причем вычисление метрики считается за одну операцию.

Итоговая оценка последовательной сложности <math>O(n^2)+O(nm)+O(m^2logm)</math>

=== Информационный граф ===
[[Файл:Инфограф.png]]

=== Ресурс параллелизма алгоритма ===
На первом этапе вычисление <math>k</math> ближайших вершин для <math>i</math>-й вершины можно распараллелить между <math>n</math> процессами (это вычисление независимо для каждой вершины).
На втором и третьем этапах процессы разбиения и объединения подграфов происходят последовательно.
Получаем оценку параллельной сложности алгоритма <math>O(nm)+O(m^2logm)</math>

=== Входные и выходные данные алгоритма ===
На вход алгоритму подается множество из <math>n</math> векторов длины <math>l</math>, описывающих объекты для кластеризации.
Также передаются параметры <math>k</math> (для построения графа k ближайших соседей на первом этапе) и <math>q</math> (используется на втором этапе для определения критерия прекращения итерационного процесса).
На выходе алгоритм выдает массив длины <math>n</math>, заполненный числами от <math>1</math> до <math>n</math>, показывающими, в какой кластер попал соответствующий объект.

==Программная реализация алгоритма==
===Особенности реализации последовательного алгоритма===
===Локальность данных и вычислений===
===Возможные способы и особенности параллельной реализации алгоритма===
===Масштабируемость алгоритма и его реализации===
[[Файл:Chameleo.png|300px]]
На приведенном графике видна зависимость эффективности от объема данных и числа процессоров для реализации алгоритма, описанной в <ref name="real">http://research.ijcaonline.org/volume79/number8/pxc3891600.pdf</ref>

===Динамические характеристики и эффективность реализации алгоритма===
===Выводы для классов архитектур===
===Существующие реализации алгоритма===

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

2017-01-25T13:32:52Z

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

{{В инкубаторе}}
== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===
Алгоритм CHAMELEON - алгоритм динамической иерархической кластеризации графа.

Кластеризация - разбиение графа на несколько подграфов таким образом, чтобы объекты внутри одного кластера были максимально близки (схожи), а данные двух различных кластеров максимально различались. Различие и схожесть объектов определяются некоей метрикой, известной заранее. Количество кластеров, на которые будет разбит граф, заранее неизвестно, и зависит от свойств объекта и выбранной метрики. Простейшей возможной метриков является расстояние между точками (если предполагать, что у каждой вершины графа есть координаты).

Алгоритм состоит из 3-х основных этапов:

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

2-й этап заключается в разбиении построенного графа на небольшие кластеры (связные подграфы)

3-й этап состоит в формировании итогового множества кластеров

=== Математическое описание алгоритма ===
'''Исходные данные'''

Множество из n объектов и заданные расстояния между объектами. Эта информация позволяет построить матрицу смежности, в которой будут указаны расстояния между соответствующими объектами по некой метрике. Матрица смежности симметрична, на главной диагонали стоят 0, поэтому достаточно хранить <math>\frac{n(n-1)}{2}</math> элементов. Кроме того задаются параметры, влияющие на работу алгоритма - число k, по которому на первом этапе строится граф по принципу k ближайших соседей, и два параметра <math>{T_{ri}}</math> и <math>{T_{rc}}</math>, используемые на третьем этапе для того, что определить, что не нужно далее продолжать кластеризацию.

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

На первом этапе строится граф <math>G(V,E)</math>, <math>V</math> - множество вершин, <math>E</math> - множество ребер, по принципу k ближайших соседей. Изначально граф состоит из множества вершин и пустого множества ребер. Для каждой вершины графа мы выбираем k других вершин, расстояния до которых минимальны (то есть k первых вершин в списке вершин графа, упорядоченных по увеличению расстояния до данной) и добавляем в множество ребер соответствующие ребра, соединяющие данную вершину с каждой из выбранных k вершин.

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

Состоит в итеративном разбиении графа на множество подграфов. Изначально (на первой итерации) разбиение состоит из единственного подграфа. Пусть <math>T</math> - множество подграфов на текущей итерации. Каждая итерация выполняется следующим образом - выбирается максимальный подграф из имеющихся в разбиении по числу вершин (то есть такой подграф <math>G_1(V_1,E_1)\in{T}: \forall {G_2(V_2,E_2)\in{T}: G_2\neq G_1} => |(V_1)|>|(V_2)|</math> ). Выбранный подграф разбивается на 2 подграфа следующим образом - сначала выбираются все разбиения <math>G_2(V_2,E_2)</math> и <math>G_3(V_3,E_3)</math>, такие, что <math>\min(|V_2|,|V_3|)\geq\frac{|V_1|}{4}</math>. Далее среди всех таких разбиений выбирается такое, для которого величина <math>\sum{|E_1^*|},E_1^* </math>- некое ребро, ведущее из вершины, попавшей в <math>G_2</math> в вершину, попавшую в <math>G_3</math>. В определенный момент, когда размер наибольшего кластера <math>|V_b|\leq{q*|V|}</math>, где <math>|V|</math> - количество вершин в изначальном графе, а <math>q</math> - предварительно заданный параметр, процесс дальнейшего разибения прекращается и алгоритм переходи на 3-й этап

'''Третий этап алгоритма:'''

Введем несколько определений:

Абсолютной взаимной связностью пары кластеров называется величина <math>EC_{({C_i},{C_j})}</math>, вычисляется как сумма весов ребер, соединяющих вершина 1-го кластера <math>C_i</math> с вершинами второго кластера <math>C_j</math>. Внутренняя связность кластера <math>E_{C_i}</math>вычисляется как сумма весов ребер, входящих в разделитель, разбивающих <math>C_i</math> на 2 равных подграфа.

Относительная взаимная связность пары кластеров <math>RI_{(C_i,C_j)}</math> вычисляется по формуле <math>RI_{(C_i,C_j)}=\frac{2*|EC_{(C_i,C_j)}|}{|EC_{C_i}|+|EC_{C_j}|}</math>

Абсолютное взаимное сходство пары кластеров <math>S_{E_{(C_i,C_j)}}</math>вычисляется как среднее сходство между связанными вершинами <math>C_i</math> и <math>C_j</math>

Относительное взаимное сходство пары кластеров <math>C_i</math> и <math>C_j</math> обозначается <math>RC_{(C_i,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_j|}{|C_i|+|C_j|}*S_{EC_{(C_j)}}}}</math>

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

Есть два различных подхода анализа сходства.

Первый - для каждой пары кластеров проверяется истинность следующих высказываний

<math>RI(Ci,Cj)\geq{T_{RI}} </math> и <math>RC_{(C_{i},C_{j})}\geq{T_{RC}}</math>

В случае, если для некоторого <math>C_i</math> существует несколько кластеров <math>C_j</math>, удовлетворяющих этим условиям, выбирается такой <math>C_j</math>, что

значение <math>EC_{(C_i,C_j)}</math> максимально.

Процесс останавливается, когда нет кластеров, удовлетворяющих указанным условиям (либо когда остался только 1 кластер)

Второй подход - выбирается такая пара кластеров, что <math>RI_{(C_i,C_j)}*RC^\alpha_{(C_i,C_j)}</math> максимально, где <math>\alpha</math> - заданный заранее параметр.

Процесс останавливается, когда нет кластеров, удовлетворяющих указанным условиям (либо когда остался только 1 кластер)

=== Вычислительное ядро алгоритма ===
На первом этапе вычислительное ядро состоит из построения графа k ближайших соседей по исходной матрице смежности (требуется для каждой вершины перебрать всех соседей и выделить k ближайших)

На втором этапе вычислительное ядро состоит из повторяющегося нахождения разбиения графа на два подграфа, удовлетворяющего ранее описанным условиям

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

=== Макроструктура алгоритма ===
В рамках первого этапа макрооперацияй считается построение графа k-ближайших соседей

В рамках второго этапа макрооперациями считаются операции разбиения подграфа.

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

=== Схема реализации последовательного алгоритма ===
Схема представлена в виде C++-подобного псевдокода, макрооперации в алгоритме выделены в соответствии с предыдущим разделом описания.
int n; // Количество точек.
int k; // Параметр k
int Dist[n][n]; // Матрица расстояний между точками.

integer E[n][n]; // Матрица рёбер графа

foreach (int i=0; i<n; i++) ) {
integer KNeighbours[k]; // список, используемый для хранения ближайших соседей
integer countN = 0;

foreach (int j=i+1; j<n; j++ ) {
//Заполняем список k ближайших соседей по матрице Dist
}

foreach (int j=0; j<k; j++) {
E[i][KNeighbours[j]] = 1;
}
}
return E;

double q; //Параметр, описание находится в соответствующем разделе.
Graph g = getBiggestGraph(); //Находим граф максимального размера
int maxSize = getSize(g); //Находим размер данного графа
while (maxSize > n * q) {
breakGraph(g); // Разбиваем граф
}

Graph graphs[m]; //Разбиение по кластерам
while (count(graphs)>1){
pairs_exist = false //Значение будет обновлено позже, если найдется подходящая пара для объединения
for (int i = 0; i < m; i++) {
for (int j = i + 1; j < m; j++) {
if (checkSimilarity(graphs[i],graphs[j])) { //Проверяем, достаточно ли схожи графы для объединения
unite(graphs[i], graphs[l])
} else {
break;
}
}
}
}

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

На втором этапе для итеративного разбиения требуется <math>O(nm)</math>операций, где <math>n</math> - количество вершин графа, а <math>m</math> - количество подграфов в итоговом разбиении.

На третьем этапе требуется <math>O(m^2logm)</math> операций, причем вычисление метрики считается за одну операцию.

Итоговая оценка последовательной сложности <math>O(n^2)+O(nm)+O(m^2logm)</math>

=== Информационный граф ===
[[Файл:Инфограф.png]]

=== Ресурс параллелизма алгоритма ===
На первом этапе вычисление <math>k</math> ближайших вершин для <math>i</math>-й вершины можно распараллелить между <math>n</math> процессами (это вычисление независимо для каждой вершины).
На втором и третьем этапах процессы разбиения и объединения подграфов происходят последовательно.
Получаем оценку параллельной сложности алгоритма <math>O(nm)+O(m^2logm)</math>

=== Входные и выходные данные алгоритма ===
На вход алгоритму подается множество из <math>n</math> векторов длины <math>l</math>, описывающих объекты для кластеризации.
Также передаются параметры <math>k</math> (для построения графа k ближайших соседей на первом этапе) и <math>q</math> (используется на втором этапе для определения критерия прекращения итерационного процесса).
На выходе алгоритм выдает массив длины <math>n</math>, заполненный числами от <math>1</math> до <math>n</math>, показывающими, в какой кластер попал соответствующий объект.

==Программная реализация алгоритма==
===Особенности реализации последовательного алгоритма===
===Локальность данных и вычислений===
===Возможные способы и особенности параллельной реализации алгоритма===
===Масштабируемость алгоритма и его реализации===
[[Файл:Chameleo.png|200px|thumb|300px]]
На приведенном графике видна зависимость эффективности от объема данных и числа процессоров для реализации алгоритма, описанной в <ref name="real">http://research.ijcaonline.org/volume79/number8/pxc3891600.pdf</ref>

===Динамические характеристики и эффективность реализации алгоритма===
===Выводы для классов архитектур===
===Существующие реализации алгоритма===

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

2017-01-25T13:32:45Z

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

{{В инкубаторе}}
== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===
Алгоритм CHAMELEON - алгоритм динамической иерархической кластеризации графа.

Кластеризация - разбиение графа на несколько подграфов таким образом, чтобы объекты внутри одного кластера были максимально близки (схожи), а данные двух различных кластеров максимально различались. Различие и схожесть объектов определяются некоей метрикой, известной заранее. Количество кластеров, на которые будет разбит граф, заранее неизвестно, и зависит от свойств объекта и выбранной метрики. Простейшей возможной метриков является расстояние между точками (если предполагать, что у каждой вершины графа есть координаты).

Алгоритм состоит из 3-х основных этапов:

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

2-й этап заключается в разбиении построенного графа на небольшие кластеры (связные подграфы)

3-й этап состоит в формировании итогового множества кластеров

=== Математическое описание алгоритма ===
'''Исходные данные'''

Множество из n объектов и заданные расстояния между объектами. Эта информация позволяет построить матрицу смежности, в которой будут указаны расстояния между соответствующими объектами по некой метрике. Матрица смежности симметрична, на главной диагонали стоят 0, поэтому достаточно хранить <math>\frac{n(n-1)}{2}</math> элементов. Кроме того задаются параметры, влияющие на работу алгоритма - число k, по которому на первом этапе строится граф по принципу k ближайших соседей, и два параметра <math>{T_{ri}}</math> и <math>{T_{rc}}</math>, используемые на третьем этапе для того, что определить, что не нужно далее продолжать кластеризацию.

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

На первом этапе строится граф <math>G(V,E)</math>, <math>V</math> - множество вершин, <math>E</math> - множество ребер, по принципу k ближайших соседей. Изначально граф состоит из множества вершин и пустого множества ребер. Для каждой вершины графа мы выбираем k других вершин, расстояния до которых минимальны (то есть k первых вершин в списке вершин графа, упорядоченных по увеличению расстояния до данной) и добавляем в множество ребер соответствующие ребра, соединяющие данную вершину с каждой из выбранных k вершин.

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

Состоит в итеративном разбиении графа на множество подграфов. Изначально (на первой итерации) разбиение состоит из единственного подграфа. Пусть <math>T</math> - множество подграфов на текущей итерации. Каждая итерация выполняется следующим образом - выбирается максимальный подграф из имеющихся в разбиении по числу вершин (то есть такой подграф <math>G_1(V_1,E_1)\in{T}: \forall {G_2(V_2,E_2)\in{T}: G_2\neq G_1} => |(V_1)|>|(V_2)|</math> ). Выбранный подграф разбивается на 2 подграфа следующим образом - сначала выбираются все разбиения <math>G_2(V_2,E_2)</math> и <math>G_3(V_3,E_3)</math>, такие, что <math>\min(|V_2|,|V_3|)\geq\frac{|V_1|}{4}</math>. Далее среди всех таких разбиений выбирается такое, для которого величина <math>\sum{|E_1^*|},E_1^* </math>- некое ребро, ведущее из вершины, попавшей в <math>G_2</math> в вершину, попавшую в <math>G_3</math>. В определенный момент, когда размер наибольшего кластера <math>|V_b|\leq{q*|V|}</math>, где <math>|V|</math> - количество вершин в изначальном графе, а <math>q</math> - предварительно заданный параметр, процесс дальнейшего разибения прекращается и алгоритм переходи на 3-й этап

'''Третий этап алгоритма:'''

Введем несколько определений:

Абсолютной взаимной связностью пары кластеров называется величина <math>EC_{({C_i},{C_j})}</math>, вычисляется как сумма весов ребер, соединяющих вершина 1-го кластера <math>C_i</math> с вершинами второго кластера <math>C_j</math>. Внутренняя связность кластера <math>E_{C_i}</math>вычисляется как сумма весов ребер, входящих в разделитель, разбивающих <math>C_i</math> на 2 равных подграфа.

Относительная взаимная связность пары кластеров <math>RI_{(C_i,C_j)}</math> вычисляется по формуле <math>RI_{(C_i,C_j)}=\frac{2*|EC_{(C_i,C_j)}|}{|EC_{C_i}|+|EC_{C_j}|}</math>

Абсолютное взаимное сходство пары кластеров <math>S_{E_{(C_i,C_j)}}</math>вычисляется как среднее сходство между связанными вершинами <math>C_i</math> и <math>C_j</math>

Относительное взаимное сходство пары кластеров <math>C_i</math> и <math>C_j</math> обозначается <math>RC_{(C_i,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_j|}{|C_i|+|C_j|}*S_{EC_{(C_j)}}}}</math>

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

Есть два различных подхода анализа сходства.

Первый - для каждой пары кластеров проверяется истинность следующих высказываний

<math>RI(Ci,Cj)\geq{T_{RI}} </math> и <math>RC_{(C_{i},C_{j})}\geq{T_{RC}}</math>

В случае, если для некоторого <math>C_i</math> существует несколько кластеров <math>C_j</math>, удовлетворяющих этим условиям, выбирается такой <math>C_j</math>, что

значение <math>EC_{(C_i,C_j)}</math> максимально.

Процесс останавливается, когда нет кластеров, удовлетворяющих указанным условиям (либо когда остался только 1 кластер)

Второй подход - выбирается такая пара кластеров, что <math>RI_{(C_i,C_j)}*RC^\alpha_{(C_i,C_j)}</math> максимально, где <math>\alpha</math> - заданный заранее параметр.

Процесс останавливается, когда нет кластеров, удовлетворяющих указанным условиям (либо когда остался только 1 кластер)

=== Вычислительное ядро алгоритма ===
На первом этапе вычислительное ядро состоит из построения графа k ближайших соседей по исходной матрице смежности (требуется для каждой вершины перебрать всех соседей и выделить k ближайших)

На втором этапе вычислительное ядро состоит из повторяющегося нахождения разбиения графа на два подграфа, удовлетворяющего ранее описанным условиям

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

=== Макроструктура алгоритма ===
В рамках первого этапа макрооперацияй считается построение графа k-ближайших соседей

В рамках второго этапа макрооперациями считаются операции разбиения подграфа.

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

=== Схема реализации последовательного алгоритма ===
Схема представлена в виде C++-подобного псевдокода, макрооперации в алгоритме выделены в соответствии с предыдущим разделом описания.
int n; // Количество точек.
int k; // Параметр k
int Dist[n][n]; // Матрица расстояний между точками.

integer E[n][n]; // Матрица рёбер графа

foreach (int i=0; i<n; i++) ) {
integer KNeighbours[k]; // список, используемый для хранения ближайших соседей
integer countN = 0;

foreach (int j=i+1; j<n; j++ ) {
//Заполняем список k ближайших соседей по матрице Dist
}

foreach (int j=0; j<k; j++) {
E[i][KNeighbours[j]] = 1;
}
}
return E;

double q; //Параметр, описание находится в соответствующем разделе.
Graph g = getBiggestGraph(); //Находим граф максимального размера
int maxSize = getSize(g); //Находим размер данного графа
while (maxSize > n * q) {
breakGraph(g); // Разбиваем граф
}

Graph graphs[m]; //Разбиение по кластерам
while (count(graphs)>1){
pairs_exist = false //Значение будет обновлено позже, если найдется подходящая пара для объединения
for (int i = 0; i < m; i++) {
for (int j = i + 1; j < m; j++) {
if (checkSimilarity(graphs[i],graphs[j])) { //Проверяем, достаточно ли схожи графы для объединения
unite(graphs[i], graphs[l])
} else {
break;
}
}
}
}

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

На втором этапе для итеративного разбиения требуется <math>O(nm)</math>операций, где <math>n</math> - количество вершин графа, а <math>m</math> - количество подграфов в итоговом разбиении.

На третьем этапе требуется <math>O(m^2logm)</math> операций, причем вычисление метрики считается за одну операцию.

Итоговая оценка последовательной сложности <math>O(n^2)+O(nm)+O(m^2logm)</math>

=== Информационный граф ===
[[Файл:Инфограф.png]]

=== Ресурс параллелизма алгоритма ===
На первом этапе вычисление <math>k</math> ближайших вершин для <math>i</math>-й вершины можно распараллелить между <math>n</math> процессами (это вычисление независимо для каждой вершины).
На втором и третьем этапах процессы разбиения и объединения подграфов происходят последовательно.
Получаем оценку параллельной сложности алгоритма <math>O(nm)+O(m^2logm)</math>

=== Входные и выходные данные алгоритма ===
На вход алгоритму подается множество из <math>n</math> векторов длины <math>l</math>, описывающих объекты для кластеризации.
Также передаются параметры <math>k</math> (для построения графа k ближайших соседей на первом этапе) и <math>q</math> (используется на втором этапе для определения критерия прекращения итерационного процесса).
На выходе алгоритм выдает массив длины <math>n</math>, заполненный числами от <math>1</math> до <math>n</math>, показывающими, в какой кластер попал соответствующий объект.

==Программная реализация алгоритма==
===Особенности реализации последовательного алгоритма===
===Локальность данных и вычислений===
===Возможные способы и особенности параллельной реализации алгоритма===
===Масштабируемость алгоритма и его реализации===
[[Файл:Chameleo.png|200px|thumb|300px]
На приведенном графике видна зависимость эффективности от объема данных и числа процессоров для реализации алгоритма, описанной в <ref name="real">http://research.ijcaonline.org/volume79/number8/pxc3891600.pdf</ref>

===Динамические характеристики и эффективность реализации алгоритма===
===Выводы для классов архитектур===
===Существующие реализации алгоритма===

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

2017-01-25T13:32:35Z

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

{{В инкубаторе}}
== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===
Алгоритм CHAMELEON - алгоритм динамической иерархической кластеризации графа.

Кластеризация - разбиение графа на несколько подграфов таким образом, чтобы объекты внутри одного кластера были максимально близки (схожи), а данные двух различных кластеров максимально различались. Различие и схожесть объектов определяются некоей метрикой, известной заранее. Количество кластеров, на которые будет разбит граф, заранее неизвестно, и зависит от свойств объекта и выбранной метрики. Простейшей возможной метриков является расстояние между точками (если предполагать, что у каждой вершины графа есть координаты).

Алгоритм состоит из 3-х основных этапов:

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

2-й этап заключается в разбиении построенного графа на небольшие кластеры (связные подграфы)

3-й этап состоит в формировании итогового множества кластеров

=== Математическое описание алгоритма ===
'''Исходные данные'''

Множество из n объектов и заданные расстояния между объектами. Эта информация позволяет построить матрицу смежности, в которой будут указаны расстояния между соответствующими объектами по некой метрике. Матрица смежности симметрична, на главной диагонали стоят 0, поэтому достаточно хранить <math>\frac{n(n-1)}{2}</math> элементов. Кроме того задаются параметры, влияющие на работу алгоритма - число k, по которому на первом этапе строится граф по принципу k ближайших соседей, и два параметра <math>{T_{ri}}</math> и <math>{T_{rc}}</math>, используемые на третьем этапе для того, что определить, что не нужно далее продолжать кластеризацию.

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

На первом этапе строится граф <math>G(V,E)</math>, <math>V</math> - множество вершин, <math>E</math> - множество ребер, по принципу k ближайших соседей. Изначально граф состоит из множества вершин и пустого множества ребер. Для каждой вершины графа мы выбираем k других вершин, расстояния до которых минимальны (то есть k первых вершин в списке вершин графа, упорядоченных по увеличению расстояния до данной) и добавляем в множество ребер соответствующие ребра, соединяющие данную вершину с каждой из выбранных k вершин.

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

Состоит в итеративном разбиении графа на множество подграфов. Изначально (на первой итерации) разбиение состоит из единственного подграфа. Пусть <math>T</math> - множество подграфов на текущей итерации. Каждая итерация выполняется следующим образом - выбирается максимальный подграф из имеющихся в разбиении по числу вершин (то есть такой подграф <math>G_1(V_1,E_1)\in{T}: \forall {G_2(V_2,E_2)\in{T}: G_2\neq G_1} => |(V_1)|>|(V_2)|</math> ). Выбранный подграф разбивается на 2 подграфа следующим образом - сначала выбираются все разбиения <math>G_2(V_2,E_2)</math> и <math>G_3(V_3,E_3)</math>, такие, что <math>\min(|V_2|,|V_3|)\geq\frac{|V_1|}{4}</math>. Далее среди всех таких разбиений выбирается такое, для которого величина <math>\sum{|E_1^*|},E_1^* </math>- некое ребро, ведущее из вершины, попавшей в <math>G_2</math> в вершину, попавшую в <math>G_3</math>. В определенный момент, когда размер наибольшего кластера <math>|V_b|\leq{q*|V|}</math>, где <math>|V|</math> - количество вершин в изначальном графе, а <math>q</math> - предварительно заданный параметр, процесс дальнейшего разибения прекращается и алгоритм переходи на 3-й этап

'''Третий этап алгоритма:'''

Введем несколько определений:

Абсолютной взаимной связностью пары кластеров называется величина <math>EC_{({C_i},{C_j})}</math>, вычисляется как сумма весов ребер, соединяющих вершина 1-го кластера <math>C_i</math> с вершинами второго кластера <math>C_j</math>. Внутренняя связность кластера <math>E_{C_i}</math>вычисляется как сумма весов ребер, входящих в разделитель, разбивающих <math>C_i</math> на 2 равных подграфа.

Относительная взаимная связность пары кластеров <math>RI_{(C_i,C_j)}</math> вычисляется по формуле <math>RI_{(C_i,C_j)}=\frac{2*|EC_{(C_i,C_j)}|}{|EC_{C_i}|+|EC_{C_j}|}</math>

Абсолютное взаимное сходство пары кластеров <math>S_{E_{(C_i,C_j)}}</math>вычисляется как среднее сходство между связанными вершинами <math>C_i</math> и <math>C_j</math>

Относительное взаимное сходство пары кластеров <math>C_i</math> и <math>C_j</math> обозначается <math>RC_{(C_i,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_j|}{|C_i|+|C_j|}*S_{EC_{(C_j)}}}}</math>

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

Есть два различных подхода анализа сходства.

Первый - для каждой пары кластеров проверяется истинность следующих высказываний

<math>RI(Ci,Cj)\geq{T_{RI}} </math> и <math>RC_{(C_{i},C_{j})}\geq{T_{RC}}</math>

В случае, если для некоторого <math>C_i</math> существует несколько кластеров <math>C_j</math>, удовлетворяющих этим условиям, выбирается такой <math>C_j</math>, что

значение <math>EC_{(C_i,C_j)}</math> максимально.

Процесс останавливается, когда нет кластеров, удовлетворяющих указанным условиям (либо когда остался только 1 кластер)

Второй подход - выбирается такая пара кластеров, что <math>RI_{(C_i,C_j)}*RC^\alpha_{(C_i,C_j)}</math> максимально, где <math>\alpha</math> - заданный заранее параметр.

Процесс останавливается, когда нет кластеров, удовлетворяющих указанным условиям (либо когда остался только 1 кластер)

=== Вычислительное ядро алгоритма ===
На первом этапе вычислительное ядро состоит из построения графа k ближайших соседей по исходной матрице смежности (требуется для каждой вершины перебрать всех соседей и выделить k ближайших)

На втором этапе вычислительное ядро состоит из повторяющегося нахождения разбиения графа на два подграфа, удовлетворяющего ранее описанным условиям

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

=== Макроструктура алгоритма ===
В рамках первого этапа макрооперацияй считается построение графа k-ближайших соседей

В рамках второго этапа макрооперациями считаются операции разбиения подграфа.

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

=== Схема реализации последовательного алгоритма ===
Схема представлена в виде C++-подобного псевдокода, макрооперации в алгоритме выделены в соответствии с предыдущим разделом описания.
int n; // Количество точек.
int k; // Параметр k
int Dist[n][n]; // Матрица расстояний между точками.

integer E[n][n]; // Матрица рёбер графа

foreach (int i=0; i<n; i++) ) {
integer KNeighbours[k]; // список, используемый для хранения ближайших соседей
integer countN = 0;

foreach (int j=i+1; j<n; j++ ) {
//Заполняем список k ближайших соседей по матрице Dist
}

foreach (int j=0; j<k; j++) {
E[i][KNeighbours[j]] = 1;
}
}
return E;

double q; //Параметр, описание находится в соответствующем разделе.
Graph g = getBiggestGraph(); //Находим граф максимального размера
int maxSize = getSize(g); //Находим размер данного графа
while (maxSize > n * q) {
breakGraph(g); // Разбиваем граф
}

Graph graphs[m]; //Разбиение по кластерам
while (count(graphs)>1){
pairs_exist = false //Значение будет обновлено позже, если найдется подходящая пара для объединения
for (int i = 0; i < m; i++) {
for (int j = i + 1; j < m; j++) {
if (checkSimilarity(graphs[i],graphs[j])) { //Проверяем, достаточно ли схожи графы для объединения
unite(graphs[i], graphs[l])
} else {
break;
}
}
}
}

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

На втором этапе для итеративного разбиения требуется <math>O(nm)</math>операций, где <math>n</math> - количество вершин графа, а <math>m</math> - количество подграфов в итоговом разбиении.

На третьем этапе требуется <math>O(m^2logm)</math> операций, причем вычисление метрики считается за одну операцию.

Итоговая оценка последовательной сложности <math>O(n^2)+O(nm)+O(m^2logm)</math>

=== Информационный граф ===
[[Файл:Инфограф.png]]

=== Ресурс параллелизма алгоритма ===
На первом этапе вычисление <math>k</math> ближайших вершин для <math>i</math>-й вершины можно распараллелить между <math>n</math> процессами (это вычисление независимо для каждой вершины).
На втором и третьем этапах процессы разбиения и объединения подграфов происходят последовательно.
Получаем оценку параллельной сложности алгоритма <math>O(nm)+O(m^2logm)</math>

=== Входные и выходные данные алгоритма ===
На вход алгоритму подается множество из <math>n</math> векторов длины <math>l</math>, описывающих объекты для кластеризации.
Также передаются параметры <math>k</math> (для построения графа k ближайших соседей на первом этапе) и <math>q</math> (используется на втором этапе для определения критерия прекращения итерационного процесса).
На выходе алгоритм выдает массив длины <math>n</math>, заполненный числами от <math>1</math> до <math>n</math>, показывающими, в какой кластер попал соответствующий объект.

==Программная реализация алгоритма==
===Особенности реализации последовательного алгоритма===
===Локальность данных и вычислений===
===Возможные способы и особенности параллельной реализации алгоритма===
===Масштабируемость алгоритма и его реализации===
[[Файл:Chameleo.png|200px|thumb]
На приведенном графике видна зависимость эффективности от объема данных и числа процессоров для реализации алгоритма, описанной в <ref name="real">http://research.ijcaonline.org/volume79/number8/pxc3891600.pdf</ref>

===Динамические характеристики и эффективность реализации алгоритма===
===Выводы для классов архитектур===
===Существующие реализации алгоритма===

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

2017-01-25T13:32:23Z

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

{{В инкубаторе}}
== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===
Алгоритм CHAMELEON - алгоритм динамической иерархической кластеризации графа.

Кластеризация - разбиение графа на несколько подграфов таким образом, чтобы объекты внутри одного кластера были максимально близки (схожи), а данные двух различных кластеров максимально различались. Различие и схожесть объектов определяются некоей метрикой, известной заранее. Количество кластеров, на которые будет разбит граф, заранее неизвестно, и зависит от свойств объекта и выбранной метрики. Простейшей возможной метриков является расстояние между точками (если предполагать, что у каждой вершины графа есть координаты).

Алгоритм состоит из 3-х основных этапов:

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

2-й этап заключается в разбиении построенного графа на небольшие кластеры (связные подграфы)

3-й этап состоит в формировании итогового множества кластеров

=== Математическое описание алгоритма ===
'''Исходные данные'''

Множество из n объектов и заданные расстояния между объектами. Эта информация позволяет построить матрицу смежности, в которой будут указаны расстояния между соответствующими объектами по некой метрике. Матрица смежности симметрична, на главной диагонали стоят 0, поэтому достаточно хранить <math>\frac{n(n-1)}{2}</math> элементов. Кроме того задаются параметры, влияющие на работу алгоритма - число k, по которому на первом этапе строится граф по принципу k ближайших соседей, и два параметра <math>{T_{ri}}</math> и <math>{T_{rc}}</math>, используемые на третьем этапе для того, что определить, что не нужно далее продолжать кластеризацию.

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

На первом этапе строится граф <math>G(V,E)</math>, <math>V</math> - множество вершин, <math>E</math> - множество ребер, по принципу k ближайших соседей. Изначально граф состоит из множества вершин и пустого множества ребер. Для каждой вершины графа мы выбираем k других вершин, расстояния до которых минимальны (то есть k первых вершин в списке вершин графа, упорядоченных по увеличению расстояния до данной) и добавляем в множество ребер соответствующие ребра, соединяющие данную вершину с каждой из выбранных k вершин.

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

Состоит в итеративном разбиении графа на множество подграфов. Изначально (на первой итерации) разбиение состоит из единственного подграфа. Пусть <math>T</math> - множество подграфов на текущей итерации. Каждая итерация выполняется следующим образом - выбирается максимальный подграф из имеющихся в разбиении по числу вершин (то есть такой подграф <math>G_1(V_1,E_1)\in{T}: \forall {G_2(V_2,E_2)\in{T}: G_2\neq G_1} => |(V_1)|>|(V_2)|</math> ). Выбранный подграф разбивается на 2 подграфа следующим образом - сначала выбираются все разбиения <math>G_2(V_2,E_2)</math> и <math>G_3(V_3,E_3)</math>, такие, что <math>\min(|V_2|,|V_3|)\geq\frac{|V_1|}{4}</math>. Далее среди всех таких разбиений выбирается такое, для которого величина <math>\sum{|E_1^*|},E_1^* </math>- некое ребро, ведущее из вершины, попавшей в <math>G_2</math> в вершину, попавшую в <math>G_3</math>. В определенный момент, когда размер наибольшего кластера <math>|V_b|\leq{q*|V|}</math>, где <math>|V|</math> - количество вершин в изначальном графе, а <math>q</math> - предварительно заданный параметр, процесс дальнейшего разибения прекращается и алгоритм переходи на 3-й этап

'''Третий этап алгоритма:'''

Введем несколько определений:

Абсолютной взаимной связностью пары кластеров называется величина <math>EC_{({C_i},{C_j})}</math>, вычисляется как сумма весов ребер, соединяющих вершина 1-го кластера <math>C_i</math> с вершинами второго кластера <math>C_j</math>. Внутренняя связность кластера <math>E_{C_i}</math>вычисляется как сумма весов ребер, входящих в разделитель, разбивающих <math>C_i</math> на 2 равных подграфа.

Относительная взаимная связность пары кластеров <math>RI_{(C_i,C_j)}</math> вычисляется по формуле <math>RI_{(C_i,C_j)}=\frac{2*|EC_{(C_i,C_j)}|}{|EC_{C_i}|+|EC_{C_j}|}</math>

Абсолютное взаимное сходство пары кластеров <math>S_{E_{(C_i,C_j)}}</math>вычисляется как среднее сходство между связанными вершинами <math>C_i</math> и <math>C_j</math>

Относительное взаимное сходство пары кластеров <math>C_i</math> и <math>C_j</math> обозначается <math>RC_{(C_i,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_j|}{|C_i|+|C_j|}*S_{EC_{(C_j)}}}}</math>

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

Есть два различных подхода анализа сходства.

Первый - для каждой пары кластеров проверяется истинность следующих высказываний

<math>RI(Ci,Cj)\geq{T_{RI}} </math> и <math>RC_{(C_{i},C_{j})}\geq{T_{RC}}</math>

В случае, если для некоторого <math>C_i</math> существует несколько кластеров <math>C_j</math>, удовлетворяющих этим условиям, выбирается такой <math>C_j</math>, что

значение <math>EC_{(C_i,C_j)}</math> максимально.

Процесс останавливается, когда нет кластеров, удовлетворяющих указанным условиям (либо когда остался только 1 кластер)

Второй подход - выбирается такая пара кластеров, что <math>RI_{(C_i,C_j)}*RC^\alpha_{(C_i,C_j)}</math> максимально, где <math>\alpha</math> - заданный заранее параметр.

Процесс останавливается, когда нет кластеров, удовлетворяющих указанным условиям (либо когда остался только 1 кластер)

=== Вычислительное ядро алгоритма ===
На первом этапе вычислительное ядро состоит из построения графа k ближайших соседей по исходной матрице смежности (требуется для каждой вершины перебрать всех соседей и выделить k ближайших)

На втором этапе вычислительное ядро состоит из повторяющегося нахождения разбиения графа на два подграфа, удовлетворяющего ранее описанным условиям

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

=== Макроструктура алгоритма ===
В рамках первого этапа макрооперацияй считается построение графа k-ближайших соседей

В рамках второго этапа макрооперациями считаются операции разбиения подграфа.

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

=== Схема реализации последовательного алгоритма ===
Схема представлена в виде C++-подобного псевдокода, макрооперации в алгоритме выделены в соответствии с предыдущим разделом описания.
int n; // Количество точек.
int k; // Параметр k
int Dist[n][n]; // Матрица расстояний между точками.

integer E[n][n]; // Матрица рёбер графа

foreach (int i=0; i<n; i++) ) {
integer KNeighbours[k]; // список, используемый для хранения ближайших соседей
integer countN = 0;

foreach (int j=i+1; j<n; j++ ) {
//Заполняем список k ближайших соседей по матрице Dist
}

foreach (int j=0; j<k; j++) {
E[i][KNeighbours[j]] = 1;
}
}
return E;

double q; //Параметр, описание находится в соответствующем разделе.
Graph g = getBiggestGraph(); //Находим граф максимального размера
int maxSize = getSize(g); //Находим размер данного графа
while (maxSize > n * q) {
breakGraph(g); // Разбиваем граф
}

Graph graphs[m]; //Разбиение по кластерам
while (count(graphs)>1){
pairs_exist = false //Значение будет обновлено позже, если найдется подходящая пара для объединения
for (int i = 0; i < m; i++) {
for (int j = i + 1; j < m; j++) {
if (checkSimilarity(graphs[i],graphs[j])) { //Проверяем, достаточно ли схожи графы для объединения
unite(graphs[i], graphs[l])
} else {
break;
}
}
}
}

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

На втором этапе для итеративного разбиения требуется <math>O(nm)</math>операций, где <math>n</math> - количество вершин графа, а <math>m</math> - количество подграфов в итоговом разбиении.

На третьем этапе требуется <math>O(m^2logm)</math> операций, причем вычисление метрики считается за одну операцию.

Итоговая оценка последовательной сложности <math>O(n^2)+O(nm)+O(m^2logm)</math>

=== Информационный граф ===
[[Файл:Инфограф.png]]

=== Ресурс параллелизма алгоритма ===
На первом этапе вычисление <math>k</math> ближайших вершин для <math>i</math>-й вершины можно распараллелить между <math>n</math> процессами (это вычисление независимо для каждой вершины).
На втором и третьем этапах процессы разбиения и объединения подграфов происходят последовательно.
Получаем оценку параллельной сложности алгоритма <math>O(nm)+O(m^2logm)</math>

=== Входные и выходные данные алгоритма ===
На вход алгоритму подается множество из <math>n</math> векторов длины <math>l</math>, описывающих объекты для кластеризации.
Также передаются параметры <math>k</math> (для построения графа k ближайших соседей на первом этапе) и <math>q</math> (используется на втором этапе для определения критерия прекращения итерационного процесса).
На выходе алгоритм выдает массив длины <math>n</math>, заполненный числами от <math>1</math> до <math>n</math>, показывающими, в какой кластер попал соответствующий объект.

==Программная реализация алгоритма==
===Особенности реализации последовательного алгоритма===
===Локальность данных и вычислений===
===Возможные способы и особенности параллельной реализации алгоритма===
===Масштабируемость алгоритма и его реализации===
[[Файл:Chameleo.png|200px]
На приведенном графике видна зависимость эффективности от объема данных и числа процессоров для реализации алгоритма, описанной в <ref name="real">http://research.ijcaonline.org/volume79/number8/pxc3891600.pdf</ref>

===Динамические характеристики и эффективность реализации алгоритма===
===Выводы для классов архитектур===
===Существующие реализации алгоритма===

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

2017-01-25T13:32:12Z

Hromovalexander: /* Программная реализация алгоритма */

{{В инкубаторе}}
== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===
Алгоритм CHAMELEON - алгоритм динамической иерархической кластеризации графа.

Кластеризация - разбиение графа на несколько подграфов таким образом, чтобы объекты внутри одного кластера были максимально близки (схожи), а данные двух различных кластеров максимально различались. Различие и схожесть объектов определяются некоей метрикой, известной заранее. Количество кластеров, на которые будет разбит граф, заранее неизвестно, и зависит от свойств объекта и выбранной метрики. Простейшей возможной метриков является расстояние между точками (если предполагать, что у каждой вершины графа есть координаты).

Алгоритм состоит из 3-х основных этапов:

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

2-й этап заключается в разбиении построенного графа на небольшие кластеры (связные подграфы)

3-й этап состоит в формировании итогового множества кластеров

=== Математическое описание алгоритма ===
'''Исходные данные'''

Множество из n объектов и заданные расстояния между объектами. Эта информация позволяет построить матрицу смежности, в которой будут указаны расстояния между соответствующими объектами по некой метрике. Матрица смежности симметрична, на главной диагонали стоят 0, поэтому достаточно хранить <math>\frac{n(n-1)}{2}</math> элементов. Кроме того задаются параметры, влияющие на работу алгоритма - число k, по которому на первом этапе строится граф по принципу k ближайших соседей, и два параметра <math>{T_{ri}}</math> и <math>{T_{rc}}</math>, используемые на третьем этапе для того, что определить, что не нужно далее продолжать кластеризацию.

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

На первом этапе строится граф <math>G(V,E)</math>, <math>V</math> - множество вершин, <math>E</math> - множество ребер, по принципу k ближайших соседей. Изначально граф состоит из множества вершин и пустого множества ребер. Для каждой вершины графа мы выбираем k других вершин, расстояния до которых минимальны (то есть k первых вершин в списке вершин графа, упорядоченных по увеличению расстояния до данной) и добавляем в множество ребер соответствующие ребра, соединяющие данную вершину с каждой из выбранных k вершин.

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

Состоит в итеративном разбиении графа на множество подграфов. Изначально (на первой итерации) разбиение состоит из единственного подграфа. Пусть <math>T</math> - множество подграфов на текущей итерации. Каждая итерация выполняется следующим образом - выбирается максимальный подграф из имеющихся в разбиении по числу вершин (то есть такой подграф <math>G_1(V_1,E_1)\in{T}: \forall {G_2(V_2,E_2)\in{T}: G_2\neq G_1} => |(V_1)|>|(V_2)|</math> ). Выбранный подграф разбивается на 2 подграфа следующим образом - сначала выбираются все разбиения <math>G_2(V_2,E_2)</math> и <math>G_3(V_3,E_3)</math>, такие, что <math>\min(|V_2|,|V_3|)\geq\frac{|V_1|}{4}</math>. Далее среди всех таких разбиений выбирается такое, для которого величина <math>\sum{|E_1^*|},E_1^* </math>- некое ребро, ведущее из вершины, попавшей в <math>G_2</math> в вершину, попавшую в <math>G_3</math>. В определенный момент, когда размер наибольшего кластера <math>|V_b|\leq{q*|V|}</math>, где <math>|V|</math> - количество вершин в изначальном графе, а <math>q</math> - предварительно заданный параметр, процесс дальнейшего разибения прекращается и алгоритм переходи на 3-й этап

'''Третий этап алгоритма:'''

Введем несколько определений:

Абсолютной взаимной связностью пары кластеров называется величина <math>EC_{({C_i},{C_j})}</math>, вычисляется как сумма весов ребер, соединяющих вершина 1-го кластера <math>C_i</math> с вершинами второго кластера <math>C_j</math>. Внутренняя связность кластера <math>E_{C_i}</math>вычисляется как сумма весов ребер, входящих в разделитель, разбивающих <math>C_i</math> на 2 равных подграфа.

Относительная взаимная связность пары кластеров <math>RI_{(C_i,C_j)}</math> вычисляется по формуле <math>RI_{(C_i,C_j)}=\frac{2*|EC_{(C_i,C_j)}|}{|EC_{C_i}|+|EC_{C_j}|}</math>

Абсолютное взаимное сходство пары кластеров <math>S_{E_{(C_i,C_j)}}</math>вычисляется как среднее сходство между связанными вершинами <math>C_i</math> и <math>C_j</math>

Относительное взаимное сходство пары кластеров <math>C_i</math> и <math>C_j</math> обозначается <math>RC_{(C_i,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_j|}{|C_i|+|C_j|}*S_{EC_{(C_j)}}}}</math>

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

Есть два различных подхода анализа сходства.

Первый - для каждой пары кластеров проверяется истинность следующих высказываний

<math>RI(Ci,Cj)\geq{T_{RI}} </math> и <math>RC_{(C_{i},C_{j})}\geq{T_{RC}}</math>

В случае, если для некоторого <math>C_i</math> существует несколько кластеров <math>C_j</math>, удовлетворяющих этим условиям, выбирается такой <math>C_j</math>, что

значение <math>EC_{(C_i,C_j)}</math> максимально.

Процесс останавливается, когда нет кластеров, удовлетворяющих указанным условиям (либо когда остался только 1 кластер)

Второй подход - выбирается такая пара кластеров, что <math>RI_{(C_i,C_j)}*RC^\alpha_{(C_i,C_j)}</math> максимально, где <math>\alpha</math> - заданный заранее параметр.

Процесс останавливается, когда нет кластеров, удовлетворяющих указанным условиям (либо когда остался только 1 кластер)

=== Вычислительное ядро алгоритма ===
На первом этапе вычислительное ядро состоит из построения графа k ближайших соседей по исходной матрице смежности (требуется для каждой вершины перебрать всех соседей и выделить k ближайших)

На втором этапе вычислительное ядро состоит из повторяющегося нахождения разбиения графа на два подграфа, удовлетворяющего ранее описанным условиям

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

=== Макроструктура алгоритма ===
В рамках первого этапа макрооперацияй считается построение графа k-ближайших соседей

В рамках второго этапа макрооперациями считаются операции разбиения подграфа.

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

=== Схема реализации последовательного алгоритма ===
Схема представлена в виде C++-подобного псевдокода, макрооперации в алгоритме выделены в соответствии с предыдущим разделом описания.
int n; // Количество точек.
int k; // Параметр k
int Dist[n][n]; // Матрица расстояний между точками.

integer E[n][n]; // Матрица рёбер графа

foreach (int i=0; i<n; i++) ) {
integer KNeighbours[k]; // список, используемый для хранения ближайших соседей
integer countN = 0;

foreach (int j=i+1; j<n; j++ ) {
//Заполняем список k ближайших соседей по матрице Dist
}

foreach (int j=0; j<k; j++) {
E[i][KNeighbours[j]] = 1;
}
}
return E;

double q; //Параметр, описание находится в соответствующем разделе.
Graph g = getBiggestGraph(); //Находим граф максимального размера
int maxSize = getSize(g); //Находим размер данного графа
while (maxSize > n * q) {
breakGraph(g); // Разбиваем граф
}

Graph graphs[m]; //Разбиение по кластерам
while (count(graphs)>1){
pairs_exist = false //Значение будет обновлено позже, если найдется подходящая пара для объединения
for (int i = 0; i < m; i++) {
for (int j = i + 1; j < m; j++) {
if (checkSimilarity(graphs[i],graphs[j])) { //Проверяем, достаточно ли схожи графы для объединения
unite(graphs[i], graphs[l])
} else {
break;
}
}
}
}

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

На втором этапе для итеративного разбиения требуется <math>O(nm)</math>операций, где <math>n</math> - количество вершин графа, а <math>m</math> - количество подграфов в итоговом разбиении.

На третьем этапе требуется <math>O(m^2logm)</math> операций, причем вычисление метрики считается за одну операцию.

Итоговая оценка последовательной сложности <math>O(n^2)+O(nm)+O(m^2logm)</math>

=== Информационный граф ===
[[Файл:Инфограф.png]]

=== Ресурс параллелизма алгоритма ===
На первом этапе вычисление <math>k</math> ближайших вершин для <math>i</math>-й вершины можно распараллелить между <math>n</math> процессами (это вычисление независимо для каждой вершины).
На втором и третьем этапах процессы разбиения и объединения подграфов происходят последовательно.
Получаем оценку параллельной сложности алгоритма <math>O(nm)+O(m^2logm)</math>

=== Входные и выходные данные алгоритма ===
На вход алгоритму подается множество из <math>n</math> векторов длины <math>l</math>, описывающих объекты для кластеризации.
Также передаются параметры <math>k</math> (для построения графа k ближайших соседей на первом этапе) и <math>q</math> (используется на втором этапе для определения критерия прекращения итерационного процесса).
На выходе алгоритм выдает массив длины <math>n</math>, заполненный числами от <math>1</math> до <math>n</math>, показывающими, в какой кластер попал соответствующий объект.

==Программная реализация алгоритма==
===Особенности реализации последовательного алгоритма===
===Локальность данных и вычислений===
===Возможные способы и особенности параллельной реализации алгоритма===
===Масштабируемость алгоритма и его реализации===
[[Файл:Chameleo.png|200px|thumb|left]]
На приведенном графике видна зависимость эффективности от объема данных и числа процессоров для реализации алгоритма, описанной в <ref name="real">http://research.ijcaonline.org/volume79/number8/pxc3891600.pdf</ref>

===Динамические характеристики и эффективность реализации алгоритма===
===Выводы для классов архитектур===
===Существующие реализации алгоритма===

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

2017-01-25T13:31:52Z

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

{{В инкубаторе}}
== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===
Алгоритм CHAMELEON - алгоритм динамической иерархической кластеризации графа.

Кластеризация - разбиение графа на несколько подграфов таким образом, чтобы объекты внутри одного кластера были максимально близки (схожи), а данные двух различных кластеров максимально различались. Различие и схожесть объектов определяются некоей метрикой, известной заранее. Количество кластеров, на которые будет разбит граф, заранее неизвестно, и зависит от свойств объекта и выбранной метрики. Простейшей возможной метриков является расстояние между точками (если предполагать, что у каждой вершины графа есть координаты).

Алгоритм состоит из 3-х основных этапов:

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

2-й этап заключается в разбиении построенного графа на небольшие кластеры (связные подграфы)

3-й этап состоит в формировании итогового множества кластеров

=== Математическое описание алгоритма ===
'''Исходные данные'''

Множество из n объектов и заданные расстояния между объектами. Эта информация позволяет построить матрицу смежности, в которой будут указаны расстояния между соответствующими объектами по некой метрике. Матрица смежности симметрична, на главной диагонали стоят 0, поэтому достаточно хранить <math>\frac{n(n-1)}{2}</math> элементов. Кроме того задаются параметры, влияющие на работу алгоритма - число k, по которому на первом этапе строится граф по принципу k ближайших соседей, и два параметра <math>{T_{ri}}</math> и <math>{T_{rc}}</math>, используемые на третьем этапе для того, что определить, что не нужно далее продолжать кластеризацию.

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

На первом этапе строится граф <math>G(V,E)</math>, <math>V</math> - множество вершин, <math>E</math> - множество ребер, по принципу k ближайших соседей. Изначально граф состоит из множества вершин и пустого множества ребер. Для каждой вершины графа мы выбираем k других вершин, расстояния до которых минимальны (то есть k первых вершин в списке вершин графа, упорядоченных по увеличению расстояния до данной) и добавляем в множество ребер соответствующие ребра, соединяющие данную вершину с каждой из выбранных k вершин.

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

Состоит в итеративном разбиении графа на множество подграфов. Изначально (на первой итерации) разбиение состоит из единственного подграфа. Пусть <math>T</math> - множество подграфов на текущей итерации. Каждая итерация выполняется следующим образом - выбирается максимальный подграф из имеющихся в разбиении по числу вершин (то есть такой подграф <math>G_1(V_1,E_1)\in{T}: \forall {G_2(V_2,E_2)\in{T}: G_2\neq G_1} => |(V_1)|>|(V_2)|</math> ). Выбранный подграф разбивается на 2 подграфа следующим образом - сначала выбираются все разбиения <math>G_2(V_2,E_2)</math> и <math>G_3(V_3,E_3)</math>, такие, что <math>\min(|V_2|,|V_3|)\geq\frac{|V_1|}{4}</math>. Далее среди всех таких разбиений выбирается такое, для которого величина <math>\sum{|E_1^*|},E_1^* </math>- некое ребро, ведущее из вершины, попавшей в <math>G_2</math> в вершину, попавшую в <math>G_3</math>. В определенный момент, когда размер наибольшего кластера <math>|V_b|\leq{q*|V|}</math>, где <math>|V|</math> - количество вершин в изначальном графе, а <math>q</math> - предварительно заданный параметр, процесс дальнейшего разибения прекращается и алгоритм переходи на 3-й этап

'''Третий этап алгоритма:'''

Введем несколько определений:

Абсолютной взаимной связностью пары кластеров называется величина <math>EC_{({C_i},{C_j})}</math>, вычисляется как сумма весов ребер, соединяющих вершина 1-го кластера <math>C_i</math> с вершинами второго кластера <math>C_j</math>. Внутренняя связность кластера <math>E_{C_i}</math>вычисляется как сумма весов ребер, входящих в разделитель, разбивающих <math>C_i</math> на 2 равных подграфа.

Относительная взаимная связность пары кластеров <math>RI_{(C_i,C_j)}</math> вычисляется по формуле <math>RI_{(C_i,C_j)}=\frac{2*|EC_{(C_i,C_j)}|}{|EC_{C_i}|+|EC_{C_j}|}</math>

Абсолютное взаимное сходство пары кластеров <math>S_{E_{(C_i,C_j)}}</math>вычисляется как среднее сходство между связанными вершинами <math>C_i</math> и <math>C_j</math>

Относительное взаимное сходство пары кластеров <math>C_i</math> и <math>C_j</math> обозначается <math>RC_{(C_i,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_j|}{|C_i|+|C_j|}*S_{EC_{(C_j)}}}}</math>

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

Есть два различных подхода анализа сходства.

Первый - для каждой пары кластеров проверяется истинность следующих высказываний

<math>RI(Ci,Cj)\geq{T_{RI}} </math> и <math>RC_{(C_{i},C_{j})}\geq{T_{RC}}</math>

В случае, если для некоторого <math>C_i</math> существует несколько кластеров <math>C_j</math>, удовлетворяющих этим условиям, выбирается такой <math>C_j</math>, что

значение <math>EC_{(C_i,C_j)}</math> максимально.

Процесс останавливается, когда нет кластеров, удовлетворяющих указанным условиям (либо когда остался только 1 кластер)

Второй подход - выбирается такая пара кластеров, что <math>RI_{(C_i,C_j)}*RC^\alpha_{(C_i,C_j)}</math> максимально, где <math>\alpha</math> - заданный заранее параметр.

Процесс останавливается, когда нет кластеров, удовлетворяющих указанным условиям (либо когда остался только 1 кластер)

=== Вычислительное ядро алгоритма ===
На первом этапе вычислительное ядро состоит из построения графа k ближайших соседей по исходной матрице смежности (требуется для каждой вершины перебрать всех соседей и выделить k ближайших)

На втором этапе вычислительное ядро состоит из повторяющегося нахождения разбиения графа на два подграфа, удовлетворяющего ранее описанным условиям

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

=== Макроструктура алгоритма ===
В рамках первого этапа макрооперацияй считается построение графа k-ближайших соседей

В рамках второго этапа макрооперациями считаются операции разбиения подграфа.

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

=== Схема реализации последовательного алгоритма ===
Схема представлена в виде C++-подобного псевдокода, макрооперации в алгоритме выделены в соответствии с предыдущим разделом описания.
int n; // Количество точек.
int k; // Параметр k
int Dist[n][n]; // Матрица расстояний между точками.

integer E[n][n]; // Матрица рёбер графа

foreach (int i=0; i<n; i++) ) {
integer KNeighbours[k]; // список, используемый для хранения ближайших соседей
integer countN = 0;

foreach (int j=i+1; j<n; j++ ) {
//Заполняем список k ближайших соседей по матрице Dist
}

foreach (int j=0; j<k; j++) {
E[i][KNeighbours[j]] = 1;
}
}
return E;

double q; //Параметр, описание находится в соответствующем разделе.
Graph g = getBiggestGraph(); //Находим граф максимального размера
int maxSize = getSize(g); //Находим размер данного графа
while (maxSize > n * q) {
breakGraph(g); // Разбиваем граф
}

Graph graphs[m]; //Разбиение по кластерам
while (count(graphs)>1){
pairs_exist = false //Значение будет обновлено позже, если найдется подходящая пара для объединения
for (int i = 0; i < m; i++) {
for (int j = i + 1; j < m; j++) {
if (checkSimilarity(graphs[i],graphs[j])) { //Проверяем, достаточно ли схожи графы для объединения
unite(graphs[i], graphs[l])
} else {
break;
}
}
}
}

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

На втором этапе для итеративного разбиения требуется <math>O(nm)</math>операций, где <math>n</math> - количество вершин графа, а <math>m</math> - количество подграфов в итоговом разбиении.

На третьем этапе требуется <math>O(m^2logm)</math> операций, причем вычисление метрики считается за одну операцию.

Итоговая оценка последовательной сложности <math>O(n^2)+O(nm)+O(m^2logm)</math>

=== Информационный граф ===
[[Файл:Инфограф.png]]

=== Ресурс параллелизма алгоритма ===
На первом этапе вычисление <math>k</math> ближайших вершин для <math>i</math>-й вершины можно распараллелить между <math>n</math> процессами (это вычисление независимо для каждой вершины).
На втором и третьем этапах процессы разбиения и объединения подграфов происходят последовательно.
Получаем оценку параллельной сложности алгоритма <math>O(nm)+O(m^2logm)</math>

=== Входные и выходные данные алгоритма ===
На вход алгоритму подается множество из <math>n</math> векторов длины <math>l</math>, описывающих объекты для кластеризации.
Также передаются параметры <math>k</math> (для построения графа k ближайших соседей на первом этапе) и <math>q</math> (используется на втором этапе для определения критерия прекращения итерационного процесса).
На выходе алгоритм выдает массив длины <math>n</math>, заполненный числами от <math>1</math> до <math>n</math>, показывающими, в какой кластер попал соответствующий объект.

==Программная реализация алгоритма==
===Особенности реализации последовательного алгоритма===
===Локальность данных и вычислений===
===Возможные способы и особенности параллельной реализации алгоритма===
===Масштабируемость алгоритма и его реализации===
[[Файл:Chameleo.png|200px|thumb|left]]
На приведенном графике видна зависимость эффективности от объема данных и числа процессоров для реализации алгоритма, описанной в <ref name="real">http://research.ijcaonline.org/volume79/number8/pxc3891600.pdf</ref>

===Динамические характеристики и эффективность реализации алгоритма===
===Выводы для классов архитектур===
===Существующие реализации алгоритма===

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

2017-01-25T13:30:20Z

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

{{В инкубаторе}}
== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===
Алгоритм CHAMELEON - алгоритм динамической иерархической кластеризации графа.

Кластеризация - разбиение графа на несколько подграфов таким образом, чтобы объекты внутри одного кластера были максимально близки (схожи), а данные двух различных кластеров максимально различались. Различие и схожесть объектов определяются некоей метрикой, известной заранее. Количество кластеров, на которые будет разбит граф, заранее неизвестно, и зависит от свойств объекта и выбранной метрики. Простейшей возможной метриков является расстояние между точками (если предполагать, что у каждой вершины графа есть координаты).

Алгоритм состоит из 3-х основных этапов:

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

2-й этап заключается в разбиении построенного графа на небольшие кластеры (связные подграфы)

3-й этап состоит в формировании итогового множества кластеров

=== Математическое описание алгоритма ===
'''Исходные данные'''

Множество из n объектов и заданные расстояния между объектами. Эта информация позволяет построить матрицу смежности, в которой будут указаны расстояния между соответствующими объектами по некой метрике. Матрица смежности симметрична, на главной диагонали стоят 0, поэтому достаточно хранить <math>\frac{n(n-1)}{2}</math> элементов. Кроме того задаются параметры, влияющие на работу алгоритма - число k, по которому на первом этапе строится граф по принципу k ближайших соседей, и два параметра <math>{T_{ri}}</math> и <math>{T_{rc}}</math>, используемые на третьем этапе для того, что определить, что не нужно далее продолжать кластеризацию.

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

На первом этапе строится граф <math>G(V,E)</math>, <math>V</math> - множество вершин, <math>E</math> - множество ребер, по принципу k ближайших соседей. Изначально граф состоит из множества вершин и пустого множества ребер. Для каждой вершины графа мы выбираем k других вершин, расстояния до которых минимальны (то есть k первых вершин в списке вершин графа, упорядоченных по увеличению расстояния до данной) и добавляем в множество ребер соответствующие ребра, соединяющие данную вершину с каждой из выбранных k вершин.

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

Состоит в итеративном разбиении графа на множество подграфов. Изначально (на первой итерации) разбиение состоит из единственного подграфа. Пусть <math>T</math> - множество подграфов на текущей итерации. Каждая итерация выполняется следующим образом - выбирается максимальный подграф из имеющихся в разбиении по числу вершин (то есть такой подграф <math>G_1(V_1,E_1)\in{T}: \forall {G_2(V_2,E_2)\in{T}: G_2\neq G_1} => |(V_1)|>|(V_2)|</math> ). Выбранный подграф разбивается на 2 подграфа следующим образом - сначала выбираются все разбиения <math>G_2(V_2,E_2)</math> и <math>G_3(V_3,E_3)</math>, такие, что <math>\min(|V_2|,|V_3|)\geq\frac{|V_1|}{4}</math>. Далее среди всех таких разбиений выбирается такое, для которого величина <math>\sum{|E_1^*|},E_1^* </math>- некое ребро, ведущее из вершины, попавшей в <math>G_2</math> в вершину, попавшую в <math>G_3</math>. В определенный момент, когда размер наибольшего кластера <math>|V_b|\leq{q*|V|}</math>, где <math>|V|</math> - количество вершин в изначальном графе, а <math>q</math> - предварительно заданный параметр, процесс дальнейшего разибения прекращается и алгоритм переходи на 3-й этап

'''Третий этап алгоритма:'''

Введем несколько определений:

Абсолютной взаимной связностью пары кластеров называется величина <math>EC_{({C_i},{C_j})}</math>, вычисляется как сумма весов ребер, соединяющих вершина 1-го кластера <math>C_i</math> с вершинами второго кластера <math>C_j</math>. Внутренняя связность кластера <math>E_{C_i}</math>вычисляется как сумма весов ребер, входящих в разделитель, разбивающих <math>C_i</math> на 2 равных подграфа.

Относительная взаимная связность пары кластеров <math>RI_{(C_i,C_j)}</math> вычисляется по формуле <math>RI_{(C_i,C_j)}=\frac{2*|EC_{(C_i,C_j)}|}{|EC_{C_i}|+|EC_{C_j}|}</math>

Абсолютное взаимное сходство пары кластеров <math>S_{E_{(C_i,C_j)}}</math>вычисляется как среднее сходство между связанными вершинами <math>C_i</math> и <math>C_j</math>

Относительное взаимное сходство пары кластеров <math>C_i</math> и <math>C_j</math> обозначается <math>RC_{(C_i,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_j|}{|C_i|+|C_j|}*S_{EC_{(C_j)}}}}</math>

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

Есть два различных подхода анализа сходства.

Первый - для каждой пары кластеров проверяется истинность следующих высказываний

<math>RI(Ci,Cj)\geq{T_{RI}} </math> и <math>RC_{(C_{i},C_{j})}\geq{T_{RC}}</math>

В случае, если для некоторого <math>C_i</math> существует несколько кластеров <math>C_j</math>, удовлетворяющих этим условиям, выбирается такой <math>C_j</math>, что

значение <math>EC_{(C_i,C_j)}</math> максимально.

Процесс останавливается, когда нет кластеров, удовлетворяющих указанным условиям (либо когда остался только 1 кластер)

Второй подход - выбирается такая пара кластеров, что <math>RI_{(C_i,C_j)}*RC^\alpha_{(C_i,C_j)}</math> максимально, где <math>\alpha</math> - заданный заранее параметр.

Процесс останавливается, когда нет кластеров, удовлетворяющих указанным условиям (либо когда остался только 1 кластер)

=== Вычислительное ядро алгоритма ===
На первом этапе вычислительное ядро состоит из построения графа k ближайших соседей по исходной матрице смежности (требуется для каждой вершины перебрать всех соседей и выделить k ближайших)

На втором этапе вычислительное ядро состоит из повторяющегося нахождения разбиения графа на два подграфа, удовлетворяющего ранее описанным условиям

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

=== Макроструктура алгоритма ===
В рамках первого этапа макрооперацияй считается построение графа k-ближайших соседей

В рамках второго этапа макрооперациями считаются операции разбиения подграфа.

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

=== Схема реализации последовательного алгоритма ===
Схема представлена в виде C++-подобного псевдокода, макрооперации в алгоритме выделены в соответствии с предыдущим разделом описания.
int n; // Количество точек.
int k; // Параметр k
int Dist[n][n]; // Матрица расстояний между точками.

integer E[n][n]; // Матрица рёбер графа

foreach (int i=0; i<n; i++) ) {
integer KNeighbours[k]; // список, используемый для хранения ближайших соседей
integer countN = 0;

foreach (int j=i+1; j<n; j++ ) {
//Заполняем список k ближайших соседей по матрице Dist
}

foreach (int j=0; j<k; j++) {
E[i][KNeighbours[j]] = 1;
}
}
return E;

double q; //Параметр, описание находится в соответствующем разделе.
Graph g = getBiggestGraph(); //Находим граф максимального размера
int maxSize = getSize(g); //Находим размер данного графа
while (maxSize > n * q) {
breakGraph(g); // Разбиваем граф
}

Graph graphs[m]; //Разбиение по кластерам
while (count(graphs)>1){
pairs_exist = false //Значение будет обновлено позже, если найдется подходящая пара для объединения
for (int i = 0; i < m; i++) {
for (int j = i + 1; j < m; j++) {
if (checkSimilarity(graphs[i],graphs[j])) { //Проверяем, достаточно ли схожи графы для объединения
unite(graphs[i], graphs[l])
} else {
break;
}
}
}
}

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

На втором этапе для итеративного разбиения требуется <math>O(nm)</math>операций, где <math>n</math> - количество вершин графа, а <math>m</math> - количество подграфов в итоговом разбиении.

На третьем этапе требуется <math>O(m^2logm)</math> операций, причем вычисление метрики считается за одну операцию.

Итоговая оценка последовательной сложности <math>O(n^2)+O(nm)+O(m^2logm)</math>

=== Информационный граф ===
[[Файл:Инфограф.png]]

=== Ресурс параллелизма алгоритма ===
На первом этапе вычисление <math>k</math> ближайших вершин для <math>i</math>-й вершины можно распараллелить между <math>n</math> процессами (это вычисление независимо для каждой вершины).
На втором и третьем этапах процессы разбиения и объединения подграфов происходят последовательно.
Получаем оценку параллельной сложности алгоритма <math>O(nm)+O(m^2logm)</math>

=== Входные и выходные данные алгоритма ===
На вход алгоритму подается множество из <math>n</math> векторов длины <math>l</math>, описывающих объекты для кластеризации.
Также передаются параметры <math>k</math> (для построения графа k ближайших соседей на первом этапе) и <math>q</math> (используется на втором этапе для определения критерия прекращения итерационного процесса).
На выходе алгоритм выдает массив длины <math>n</math>, заполненный числами от <math>1</math> до <math>n</math>, показывающими, в какой кластер попал соответствующий объект.

==Программная реализация алгоритма==
===Особенности реализации последовательного алгоритма===
===Локальность данных и вычислений===
===Возможные способы и особенности параллельной реализации алгоритма===
===Масштабируемость алгоритма и его реализации===
[[Файл:Chameleo.png|200px|thumb|left]]
На приведенном графике видна зависимость эффективности от объема данных и числа процессоров для реализации алгоритма, описанной в [[2]]

===Динамические характеристики и эффективность реализации алгоритма===
===Выводы для классов архитектур===
===Существующие реализации алгоритма===

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

2017-01-25T12:55:28Z

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

{{В инкубаторе}}
== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===
Алгоритм CHAMELEON - алгоритм динамической иерархической кластеризации графа.

Кластеризация - разбиение графа на несколько подграфов таким образом, чтобы объекты внутри одного кластера были максимально близки (схожи), а данные двух различных кластеров максимально различались. Различие и схожесть объектов определяются некоей метрикой, известной заранее. Количество кластеров, на которые будет разбит граф, заранее неизвестно, и зависит от свойств объекта и выбранной метрики. Простейшей возможной метриков является расстояние между точками (если предполагать, что у каждой вершины графа есть координаты).

Алгоритм состоит из 3-х основных этапов:

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

2-й этап заключается в разбиении построенного графа на небольшие кластеры (связные подграфы)

3-й этап состоит в формировании итогового множества кластеров

=== Математическое описание алгоритма ===
'''Исходные данные'''

Множество из n объектов и заданные расстояния между объектами. Эта информация позволяет построить матрицу смежности, в которой будут указаны расстояния между соответствующими объектами по некой метрике. Матрица смежности симметрична, на главной диагонали стоят 0, поэтому достаточно хранить <math>\frac{n(n-1)}{2}</math> элементов. Кроме того задаются параметры, влияющие на работу алгоритма - число k, по которому на первом этапе строится граф по принципу k ближайших соседей, и два параметра <math>{T_{ri}}</math> и <math>{T_{rc}}</math>, используемые на третьем этапе для того, что определить, что не нужно далее продолжать кластеризацию.

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

На первом этапе строится граф <math>G(V,E)</math>, <math>V</math> - множество вершин, <math>E</math> - множество ребер, по принципу k ближайших соседей. Изначально граф состоит из множества вершин и пустого множества ребер. Для каждой вершины графа мы выбираем k других вершин, расстояния до которых минимальны (то есть k первых вершин в списке вершин графа, упорядоченных по увеличению расстояния до данной) и добавляем в множество ребер соответствующие ребра, соединяющие данную вершину с каждой из выбранных k вершин.

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

Состоит в итеративном разбиении графа на множество подграфов. Изначально (на первой итерации) разбиение состоит из единственного подграфа. Пусть <math>T</math> - множество подграфов на текущей итерации. Каждая итерация выполняется следующим образом - выбирается максимальный подграф из имеющихся в разбиении по числу вершин (то есть такой подграф <math>G_1(V_1,E_1)\in{T}: \forall {G_2(V_2,E_2)\in{T}: G_2\neq G_1} => |(V_1)|>|(V_2)|</math> ). Выбранный подграф разбивается на 2 подграфа следующим образом - сначала выбираются все разбиения <math>G_2(V_2,E_2)</math> и <math>G_3(V_3,E_3)</math>, такие, что <math>\min(|V_2|,|V_3|)\geq\frac{|V_1|}{4}</math>. Далее среди всех таких разбиений выбирается такое, для которого величина <math>\sum{|E_1^*|},E_1^* </math>- некое ребро, ведущее из вершины, попавшей в <math>G_2</math> в вершину, попавшую в <math>G_3</math>. В определенный момент, когда размер наибольшего кластера <math>|V_b|\leq{q*|V|}</math>, где <math>|V|</math> - количество вершин в изначальном графе, а <math>q</math> - предварительно заданный параметр, процесс дальнейшего разибения прекращается и алгоритм переходи на 3-й этап

'''Третий этап алгоритма:'''

Введем несколько определений:

Абсолютной взаимной связностью пары кластеров называется величина <math>EC_{({C_i},{C_j})}</math>, вычисляется как сумма весов ребер, соединяющих вершина 1-го кластера <math>C_i</math> с вершинами второго кластера <math>C_j</math>. Внутренняя связность кластера <math>E_{C_i}</math>вычисляется как сумма весов ребер, входящих в разделитель, разбивающих <math>C_i</math> на 2 равных подграфа.

Относительная взаимная связность пары кластеров <math>RI_{(C_i,C_j)}</math> вычисляется по формуле <math>RI_{(C_i,C_j)}=\frac{2*|EC_{(C_i,C_j)}|}{|EC_{C_i}|+|EC_{C_j}|}</math>

Абсолютное взаимное сходство пары кластеров <math>S_{E_{(C_i,C_j)}}</math>вычисляется как среднее сходство между связанными вершинами <math>C_i</math> и <math>C_j</math>

Относительное взаимное сходство пары кластеров <math>C_i</math> и <math>C_j</math> обозначается <math>RC_{(C_i,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_j|}{|C_i|+|C_j|}*S_{EC_{(C_j)}}}}</math>

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

Есть два различных подхода анализа сходства.

Первый - для каждой пары кластеров проверяется истинность следующих высказываний

<math>RI(Ci,Cj)\geq{T_{RI}} </math> и <math>RC_{(C_{i},C_{j})}\geq{T_{RC}}</math>

В случае, если для некоторого <math>C_i</math> существует несколько кластеров <math>C_j</math>, удовлетворяющих этим условиям, выбирается такой <math>C_j</math>, что

значение <math>EC_{(C_i,C_j)}</math> максимально.

Процесс останавливается, когда нет кластеров, удовлетворяющих указанным условиям (либо когда остался только 1 кластер)

Второй подход - выбирается такая пара кластеров, что <math>RI_{(C_i,C_j)}*RC^\alpha_{(C_i,C_j)}</math> максимально, где <math>\alpha</math> - заданный заранее параметр.

Процесс останавливается, когда нет кластеров, удовлетворяющих указанным условиям (либо когда остался только 1 кластер)

=== Вычислительное ядро алгоритма ===
На первом этапе вычислительное ядро состоит из построения графа k ближайших соседей по исходной матрице смежности (требуется для каждой вершины перебрать всех соседей и выделить k ближайших)

На втором этапе вычислительное ядро состоит из повторяющегося нахождения разбиения графа на два подграфа, удовлетворяющего ранее описанным условиям

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

=== Макроструктура алгоритма ===
В рамках первого этапа макрооперацияй считается построение графа k-ближайших соседей

В рамках второго этапа макрооперациями считаются операции разбиения подграфа.

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

=== Схема реализации последовательного алгоритма ===
Схема представлена в виде C++-подобного псевдокода, макрооперации в алгоритме выделены в соответствии с предыдущим разделом описания.
int n; // Количество точек.
int k; // Параметр k
int Dist[n][n]; // Матрица расстояний между точками.

integer E[n][n]; // Матрица рёбер графа

foreach (int i=0; i<n; i++) ) {
integer KNeighbours[k]; // список, используемый для хранения ближайших соседей
integer countN = 0;

foreach (int j=i+1; j<n; j++ ) {
//Заполняем список k ближайших соседей по матрице Dist
}

foreach (int j=0; j<k; j++) {
E[i][KNeighbours[j]] = 1;
}
}
return E;

double q; //Параметр, описание находится в соответствующем разделе.
Graph g = getBiggestGraph(); //Находим граф максимального размера
int maxSize = getSize(g); //Находим размер данного графа
while (maxSize > n * q) {
breakGraph(g); // Разбиваем граф
}

Graph graphs[m]; //Разбиение по кластерам
while (count(graphs)>1){
pairs_exist = false //Значение будет обновлено позже, если найдется подходящая пара для объединения
for (int i = 0; i < m; i++) {
for (int j = i + 1; j < m; j++) {
if (checkSimilarity(graphs[i],graphs[j])) { //Проверяем, достаточно ли схожи графы для объединения
unite(graphs[i], graphs[l])
} else {
break;
}
}
}
}

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

На втором этапе для итеративного разбиения требуется <math>O(nm)</math>операций, где <math>n</math> - количество вершин графа, а <math>m</math> - количество подграфов в итоговом разбиении.

На третьем этапе требуется <math>O(m^2logm)</math> операций, причем вычисление метрики считается за одну операцию.

Итоговая оценка последовательной сложности <math>O(n^2)+O(nm)+O(m^2logm)</math>

=== Информационный граф ===
[[Файл:Инфограф.png]]

=== Ресурс параллелизма алгоритма ===
На первом этапе вычисление <math>k</math> ближайших вершин для <math>i</math>-й вершины можно распараллелить между <math>n</math> процессами (это вычисление независимо для каждой вершины).
На втором и третьем этапах процессы разбиения и объединения подграфов происходят последовательно.
Получаем оценку параллельной сложности алгоритма <math>O(nm)+O(m^2logm)</math>

=== Входные и выходные данные алгоритма ===
На вход алгоритму подается множество из <math>n</math> векторов длины <math>l</math>, описывающих объекты для кластеризации.
Также передаются параметры <math>k</math> (для построения графа k ближайших соседей на первом этапе) и <math>q</math> (используется на втором этапе для определения критерия прекращения итерационного процесса).
На выходе алгоритм выдает массив длины <math>n</math>, заполненный числами от <math>1</math> до <math>n</math>, показывающими, в какой кластер попал соответствующий объект.

==Программная реализация алгоритма==
===Особенности реализации последовательного алгоритма===
===Локальность данных и вычислений===
===Возможные способы и особенности параллельной реализации алгоритма===
===Масштабируемость алгоритма и его реализации===
[[Файл:Chameleo.png|200px|thumb|left]]

===Динамические характеристики и эффективность реализации алгоритма===
===Выводы для классов архитектур===
===Существующие реализации алгоритма===

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

2017-01-25T12:27:19Z

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

{{В инкубаторе}}
== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===
Алгоритм CHAMELEON - алгоритм динамической иерархической кластеризации графа.

Кластеризация - разбиение графа на несколько подграфов таким образом, чтобы объекты внутри одного кластера были максимально близки (схожи), а данные двух различных кластеров максимально различались. Различие и схожесть объектов определяются некоей метрикой, известной заранее. Количество кластеров, на которые будет разбит граф, заранее неизвестно, и зависит от свойств объекта и выбранной метрики. Простейшей возможной метриков является расстояние между точками (если предполагать, что у каждой вершины графа есть координаты).

Алгоритм состоит из 3-х основных этапов:

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

2-й этап заключается в разбиении построенного графа на небольшие кластеры (связные подграфы)

3-й этап состоит в формировании итогового множества кластеров

=== Математическое описание алгоритма ===
'''Исходные данные'''

Множество из n объектов и заданные расстояния между объектами. Эта информация позволяет построить матрицу смежности, в которой будут указаны расстояния между соответствующими объектами по некой метрике. Матрица смежности симметрична, на главной диагонали стоят 0, поэтому достаточно хранить <math>\frac{n(n-1)}{2}</math> элементов. Кроме того задаются параметры, влияющие на работу алгоритма - число k, по которому на первом этапе строится граф по принципу k ближайших соседей, и два параметра <math>{T_{ri}}</math> и <math>{T_{rc}}</math>, используемые на третьем этапе для того, что определить, что не нужно далее продолжать кластеризацию.

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

На первом этапе строится граф <math>G(V,E)</math>, <math>V</math> - множество вершин, <math>E</math> - множество ребер, по принципу k ближайших соседей. Изначально граф состоит из множества вершин и пустого множества ребер. Для каждой вершины графа мы выбираем k других вершин, расстояния до которых минимальны (то есть k первых вершин в списке вершин графа, упорядоченных по увеличению расстояния до данной) и добавляем в множество ребер соответствующие ребра, соединяющие данную вершину с каждой из выбранных k вершин.

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

Состоит в итеративном разбиении графа на множество подграфов. Изначально (на первой итерации) разбиение состоит из единственного подграфа. Пусть <math>T</math> - множество подграфов на текущей итерации. Каждая итерация выполняется следующим образом - выбирается максимальный подграф из имеющихся в разбиении по числу вершин (то есть такой подграф <math>G_1(V_1,E_1)\in{T}: \forall {G_2(V_2,E_2)\in{T}: G_2\neq G_1} => |(V_1)|>|(V_2)|</math> ). Выбранный подграф разбивается на 2 подграфа следующим образом - сначала выбираются все разбиения <math>G_2(V_2,E_2)</math> и <math>G_3(V_3,E_3)</math>, такие, что <math>\min(|V_2|,|V_3|)\geq\frac{|V_1|}{4}</math>. Далее среди всех таких разбиений выбирается такое, для которого величина <math>\sum{|E_1^*|},E_1^* </math>- некое ребро, ведущее из вершины, попавшей в <math>G_2</math> в вершину, попавшую в <math>G_3</math>. В определенный момент, когда размер наибольшего кластера <math>|V_b|\leq{q*|V|}</math>, где <math>|V|</math> - количество вершин в изначальном графе, а <math>q</math> - предварительно заданный параметр, процесс дальнейшего разибения прекращается и алгоритм переходи на 3-й этап

'''Третий этап алгоритма:'''

Введем несколько определений:

Абсолютной взаимной связностью пары кластеров называется величина <math>EC_{({C_i},{C_j})}</math>, вычисляется как сумма весов ребер, соединяющих вершина 1-го кластера <math>C_i</math> с вершинами второго кластера <math>C_j</math>. Внутренняя связность кластера <math>E_{C_i}</math>вычисляется как сумма весов ребер, входящих в разделитель, разбивающих <math>C_i</math> на 2 равных подграфа.

Относительная взаимная связность пары кластеров <math>RI_{(C_i,C_j)}</math> вычисляется по формуле <math>RI_{(C_i,C_j)}=\frac{2*|EC_{(C_i,C_j)}|}{|EC_{C_i}|+|EC_{C_j}|}</math>

Абсолютное взаимное сходство пары кластеров <math>S_{E_{(C_i,C_j)}}</math>вычисляется как среднее сходство между связанными вершинами <math>C_i</math> и <math>C_j</math>

Относительное взаимное сходство пары кластеров <math>C_i</math> и <math>C_j</math> обозначается <math>RC_{(C_i,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_j|}{|C_i|+|C_j|}*S_{EC_{(C_j)}}}}</math>

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

Есть два различных подхода анализа сходства.

Первый - для каждой пары кластеров проверяется истинность следующих высказываний

<math>RI(Ci,Cj)\geq{T_{RI}} </math> и <math>RC_{(C_{i},C_{j})}\geq{T_{RC}}</math>

В случае, если для некоторого <math>C_i</math> существует несколько кластеров <math>C_j</math>, удовлетворяющих этим условиям, выбирается такой <math>C_j</math>, что

значение <math>EC_{(C_i,C_j)}</math> максимально.

Процесс останавливается, когда нет кластеров, удовлетворяющих указанным условиям (либо когда остался только 1 кластер)

Второй подход - выбирается такая пара кластеров, что <math>RI_{(C_i,C_j)}*RC^\alpha_{(C_i,C_j)}</math> максимально, где <math>\alpha</math> - заданный заранее параметр.

Процесс останавливается, когда нет кластеров, удовлетворяющих указанным условиям (либо когда остался только 1 кластер)

=== Вычислительное ядро алгоритма ===
На первом этапе вычислительное ядро состоит из построения графа k ближайших соседей по исходной матрице смежности (требуется для каждой вершины перебрать всех соседей и выделить k ближайших)

На втором этапе вычислительное ядро состоит из повторяющегося нахождения разбиения графа на два подграфа, удовлетворяющего ранее описанным условиям

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

=== Макроструктура алгоритма ===
В рамках первого этапа макрооперацияй считается построение графа k-ближайших соседей

В рамках второго этапа макрооперациями считаются операции разбиения подграфа.

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

=== Схема реализации последовательного алгоритма ===
Схема представлена в виде C++-подобного псевдокода, макрооперации в алгоритме выделены в соответствии с предыдущим разделом описания.
int n; // Количество точек.
int k; // Параметр k
int Dist[n][n]; // Матрица расстояний между точками.

integer E[n][n]; // Матрица рёбер графа

foreach (int i=0; i<n; i++) ) {
integer KNeighbours[k]; // список, используемый для хранения ближайших соседей
integer countN = 0;

foreach (int j=i+1; j<n; j++ ) {
//Заполняем список k ближайших соседей по матрице Dist
}

foreach (int j=0; j<k; j++) {
E[i][KNeighbours[j]] = 1;
}
}
return E;

double q; //Параметр, описание находится в соответствующем разделе.
Graph g = getBiggestGraph(); //Находим граф максимального размера
int maxSize = getSize(g); //Находим размер данного графа
while (maxSize > n * q) {
breakGraph(g); // Разбиваем граф
}

Graph graphs[m]; //Разбиение по кластерам
while (count(graphs)>1){
pairs_exist = false //Значение будет обновлено позже, если найдется подходящая пара для объединения
for (int i = 0; i < m; i++) {
for (int j = i + 1; j < m; j++) {
if (checkSimilarity(graphs[i],graphs[j])) { //Проверяем, достаточно ли схожи графы для объединения
unite(graphs[i], graphs[l])
} else {
break;
}
}
}
}

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

На втором этапе для итеративного разбиения требуется <math>O(nm)</math>операций, где <math>n</math> - количество вершин графа, а <math>m</math> - количество подграфов в итоговом разбиении.

На третьем этапе требуется <math>O(m^2logm)</math> операций, причем вычисление метрики считается за одну операцию.

Итоговая оценка последовательной сложности <math>O(n^2)+O(nm)+O(m^2logm)</math>

=== Информационный граф ===
[[Файл:Инфограф.png]]

=== Ресурс параллелизма алгоритма ===
На первом этапе вычисление <math>k</math> ближайших вершин для <math>i</math>-й вершины можно распараллелить между <math>n</math> процессами (это вычисление независимо для каждой вершины).
На втором и третьем этапах процессы разбиения и объединения подграфов происходят последовательно.
Получаем оценку параллельной сложности алгоритма <math>O(nm)+O(m^2logm)</math>

=== Входные и выходные данные алгоритма ===
На вход алгоритму подается множество из <math>n</math> векторов длины <math>l</math>, описывающих объекты для кластеризации.
Также передаются параметры <math>k</math> (для построения графа k ближайших соседей на первом этапе) и <math>q</math> (используется на втором этапе для определения критерия прекращения итерационного процесса).
На выходе алгоритм выдает массив длины <math>n</math>, заполненный числами от <math>1</math> до <math>n</math>, показывающими, в какой кластер попал соответствующий объект.

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

===Динамические характеристики и эффективность реализации алгоритма===
===Выводы для классов архитектур===
===Существующие реализации алгоритма===

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

2017-01-25T12:20:58Z

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

{{В инкубаторе}}
== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===
Алгоритм CHAMELEON - алгоритм динамической иерархической кластеризации графа.

Кластеризация - разбиение графа на несколько подграфов таким образом, чтобы объекты внутри одного кластера были максимально близки (схожи), а данные двух различных кластеров максимально различались. Различие и схожесть объектов определяются некоей метрикой, известной заранее. Количество кластеров, на которые будет разбит граф, заранее неизвестно, и зависит от свойств объекта и выбранной метрики. Простейшей возможной метриков является расстояние между точками (если предполагать, что у каждой вершины графа есть координаты).

Алгоритм состоит из 3-х основных этапов:

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

2-й этап заключается в разбиении построенного графа на небольшие кластеры (связные подграфы)

3-й этап состоит в формировании итогового множества кластеров

=== Математическое описание алгоритма ===
'''Исходные данные'''

Множество из n объектов и заданные расстояния между объектами. Эта информация позволяет построить матрицу смежности, в которой будут указаны расстояния между соответствующими объектами по некой метрике. Матрица смежности симметрична, на главной диагонали стоят 0, поэтому достаточно хранить <math>\frac{n(n-1)}{2}</math> элементов. Кроме того задаются параметры, влияющие на работу алгоритма - число k, по которому на первом этапе строится граф по принципу k ближайших соседей, и два параметра <math>{T_{ri}}</math> и <math>{T_{rc}}</math>, используемые на третьем этапе для того, что определить, что не нужно далее продолжать кластеризацию.

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

На первом этапе строится граф <math>G(V,E)</math>, <math>V</math> - множество вершин, <math>E</math> - множество ребер, по принципу k ближайших соседей. Изначально граф состоит из множества вершин и пустого множества ребер. Для каждой вершины графа мы выбираем k других вершин, расстояния до которых минимальны (то есть k первых вершин в списке вершин графа, упорядоченных по увеличению расстояния до данной) и добавляем в множество ребер соответствующие ребра, соединяющие данную вершину с каждой из выбранных k вершин.

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

Состоит в итеративном разбиении графа на множество подграфов. Изначально (на первой итерации) разбиение состоит из единственного подграфа. Пусть <math>T</math> - множество подграфов на текущей итерации. Каждая итерация выполняется следующим образом - выбирается максимальный подграф из имеющихся в разбиении по числу вершин (то есть такой подграф <math>G_1(V_1,E_1)\in{T}: \forall {G_2(V_2,E_2)\in{T}: G_2\neq G_1} => |(V_1)|>|(V_2)|</math> ). Выбранный подграф разбивается на 2 подграфа следующим образом - сначала выбираются все разбиения <math>G_2(V_2,E_2)</math> и <math>G_3(V_3,E_3)</math>, такие, что <math>\min(|V_2|,|V_3|)\geq\frac{|V_1|}{4}</math>. Далее среди всех таких разбиений выбирается такое, для которого величина <math>\sum{|E_1^*|},E_1^* </math>- некое ребро, ведущее из вершины, попавшей в <math>G_2</math> в вершину, попавшую в <math>G_3</math>. В определенный момент, когда размер наибольшего кластера <math>|V_b|\leq{q*|V|}</math>, где <math>|V|</math> - количество вершин в изначальном графе, а <math>q</math> - предварительно заданный параметр, процесс дальнейшего разибения прекращается и алгоритм переходи на 3-й этап

'''Третий этап алгоритма:'''

Введем несколько определений:

Абсолютной взаимной связностью пары кластеров называется величина <math>EC_{({C_i},{C_j})}</math>, вычисляется как сумма весов ребер, соединяющих вершина 1-го кластера <math>C_i</math> с вершинами второго кластера <math>C_j</math>. Внутренняя связность кластера <math>E_{C_i}</math>вычисляется как сумма весов ребер, входящих в разделитель, разбивающих <math>C_i</math> на 2 равных подграфа.

Относительная взаимная связность пары кластеров <math>RI_{(C_i,C_j)}</math> вычисляется по формуле <math>RI_{(C_i,C_j)}=\frac{2*|EC_{(C_i,C_j)}|}{|EC_{C_i}|+|EC_{C_j}|}</math>

Абсолютное взаимное сходство пары кластеров <math>S_{E_{(C_i,C_j)}}</math>вычисляется как среднее сходство между связанными вершинами <math>C_i</math> и <math>C_j</math>

Относительное взаимное сходство пары кластеров <math>C_i</math> и <math>C_j</math> обозначается <math>RC_{(C_i,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_j|}{|C_i|+|C_j|}*S_{EC_{(C_j)}}}}</math>

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

Есть два различных подхода анализа сходства.

Первый - для каждой пары кластеров проверяется истинность следующих высказываний

<math>RI(Ci,Cj)\geq{T_{RI}} </math> и <math>RC_{(C_{i},C_{j})}\geq{T_{RC}}</math>

В случае, если для некоторого <math>C_i</math> существует несколько кластеров <math>C_j</math>, удовлетворяющих этим условиям, выбирается такой <math>C_j</math>, что

значение <math>EC_{(C_i,C_j)}</math> максимально.

Процесс останавливается, когда нет кластеров, удовлетворяющих указанным условиям (либо когда остался только 1 кластер)

Второй подход - выбирается такая пара кластеров, что <math>RI_{(C_i,C_j)}*RC^\alpha_{(C_i,C_j)}</math> максимально, где <math>\alpha</math> - заданный заранее параметр.

Процесс останавливается, когда нет кластеров, удовлетворяющих указанным условиям (либо когда остался только 1 кластер)

=== Вычислительное ядро алгоритма ===
На первом этапе вычислительное ядро состоит из построения графа k ближайших соседей по исходной матрице смежности (требуется для каждой вершины перебрать всех соседей и выделить k ближайших)

На втором этапе вычислительное ядро состоит из повторяющегося нахождения разбиения графа на два подграфа, удовлетворяющего ранее описанным условиям

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

=== Макроструктура алгоритма ===
В рамках первого этапа макрооперацияй считается построение графа k-ближайших соседей

В рамках второго этапа макрооперациями считаются операции разбиения подграфа.

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

=== Схема реализации последовательного алгоритма ===
Схема представлена в виде C++-подобного псевдокода, макрооперации в алгоритме выделены в соответствии с предыдущим разделом описания.
int n; // Количество точек.
int k; // Параметр k
int Dist[n][n]; // Матрица расстояний между точками.

integer E[n][n]; // Матрица рёбер графа

foreach (int i=0; i<n; i++) ) {
integer KNeighbours[k]; // список, используемый для хранения ближайших соседей
integer countN = 0;

foreach (int j=i+1; j<n; j++ ) {
//Заполняем список k ближайших соседей по матрице Dist
}

foreach (int j=0; j<k; j++) {
E[i][KNeighbours[j]] = 1;
}
}
return E;

double q; //Параметр, описание находится в соответствующем разделе.
Graph g = getBiggestGraph(); //Находим граф максимального размера
int maxSize = getSize(g); //Находим размер данного графа
while (maxSize > n * q) {
breakGraph(g); // Разбиваем граф
}

Graph graphs[m]; //Разбиение по кластерам
while (count(graphs)>1){
pairs_exist = false //Значение будет обновлено позже, если найдется подходящая пара для объединения
for (int i = 0; i < m; i++) {
for (int j = i + 1; j < m; j++) {
if (checkSimilarity(graphs[i],graphs[j])) { //Проверяем, достаточно ли схожи графы для объединения
unite(graphs[i], graphs[l])
} else {
break;
}
}
}
}

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

На втором этапе для итеративного разбиения требуется <math>O(nm)</math>операций, где <math>n</math> - количество вершин графа, а <math>m</math> - количество подграфов в итоговом разбиении.

На третьем этапе требуется <math>O(m^2logm)</math> операций, причем вычисление метрики считается за одну операцию.

Итоговая оценка последовательной сложности <math>O(n^2)+O(nm)+O(m^2logm)</math>

=== Информационный граф ===
[[Файл:Инфограф.png]]

=== Ресурс параллелизма алгоритма ===
На первом этапе вычисление <math>k</math> ближайших вершин для <math>i</math>-й вершины можно распараллелить между <math>n</math> процессами (это вычисление независимо для каждой вершины).
На втором и третьем этапах процессы разбиения и объединения подграфов происходят последовательно.
Получаем оценку параллельной сложности алгоритма <math>O(nm)+O(m^2logm)</math>

=== Входные и выходные данные алгоритма ===
На вход алгоритму подается множество из <math>n</math> векторов длины <math>l</math>, описывающих объекты для кластеризации.
Также передаются параметры <math>k</math> (для построения графа k ближайших соседей на первом этапе) и <math>q</math> (используется на втором этапе для определения критерия прекращения итерационного процесса).
На выходе алгоритм выдает массив длины <math>n</math>, заполненный числами от <math>1</math> до <math>n</math>, показывающими, в какой кластер попал соответствующий объект.

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

Участник:Ruslanlazovskiy/CHAMELEON

2017-01-25T12:19:57Z

Hromovalexander: Отмена правки 21740, сделанной участником Hromovalexander (обс.)

{{Assignment|Algoman|Kronberg}}

{{algorithm
| name = CHAMELEON
| serial_complexity = <math>O(n*m + n*log{n} + m*log{m})</math>
| pf_height = <math>O(n)</math> - этап 1. <math>O(q)</math> - отдельная итерация этапа 3.
| pf_width = <math>O(n)</math> - этап 1. <math>O(q)</math> - отдельная итерация этапа 3.
| input_data = <math>n^2 / 2</math>
| output_data = <math>n</math>
}}

Авторы статьи:
[https://algowiki-project.org/ru/%D0%A3%D1%87%D0%B0%D1%81%D1%82%D0%BD%D0%B8%D0%BA:Ruslanlazovskiy Лазовский Р. А.] (разделы 1.1 - 1.4 , 1.7 , 1.8),
[https://algowiki-project.org/ru/%D0%A3%D1%87%D0%B0%D1%81%D1%82%D0%BD%D0%B8%D0%BA:%D0%9C%D1%83%D1%81%D1%82%D0%B0%D1%84%D0%B0%D0%B5%D0%B2_%D0%AD%D0%BB%D1%8C%D0%B2%D0%B8%D0%BD_%D0%AD%D0%BB%D1%8C%D0%BC%D0%B0%D0%BD%D0%BE%D0%B2%D0%B8%D1%87 Мустафаев Э. Э.] (разделы 1.5 , 1.6 , 1.9 , 1.10 , 2.2)

==Свойства и структура алгоритма==
===Общее описание алгоритма===
CHAMELEON – алгоритм динамической иерархической кластеризации графа, то есть процесса разбиения графа на несколько подграфов-кластеров таким образом, что данные внутри одного кластера имеют максимально схожи, а данные в разных кластерах — максимально различны. В классических алгоритмах кластеризации схожесть объектов определяется с помощью некоторой метрики (простейший пример — евклидова метрика). Не следует путать задачу кластеризации с задачей классификации: в последней характеристики объекта, необходимые для попадания в тот или иной класс, известны заранее, в рассматриваемой же задаче они становятся известны в процессе решения. Первоначально алгоритм был описан в статье<ref>CHAMELEON: A Hierarchical Clustering Algorithm Using Dynamic Modeling. George Karypis, Eui-Hong Han, Vipin Kumar. IEEE Computer 32(8): 68-75, 1999</ref>.

Алгоритм CHAMELEON работает в 3 этапа. На первом этапе исходное множество объектов организуется в граф по принципу k ближайших соседей. На втором этапе этого граф разбивается на достаточно малые подграфы-кластеры. На третьем этапе происходит агломеративная иерархическая кластеризация полученных подграфов в соответствии с одной из выбранных метрик (возможные метрики будут подробно описаны далее). Число получаемых в итоге кластеров в явном виде не задаётся.

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

Исходные данные: Первоначально исходными данными алгоритма являются <math>n</math> векторов длины <math>p</math>, каждый из которых соответствует одному объекту. На основании значений элементов этих векторов строится матрица смежности размера <math>n * n</math>, возможно сокращение требуемого объема памяти до <math>(n*(n - 1))/ 2</math> в соответствии с выбранной метрикой. К исходным данным также относится набор параметров. Это <math>k</math> - количество ближайших соседей на первом этапе алгоритма, <math>q</math> - отношение количества вершин в наибольшем подграфе по отношению к общему числу объектов на втором этапе алгоритма, а также параметры <math>T_{RI}, T_{RI}</math> - пороговые значения, после которых прекращается агломеративная кластеризация на третьем этапе. Следует особо отметить, что число получаемых в итоге кластеров заранее не известно, хотя на него и можно повлиять изменением значений перечисленных параметров.

Первый этап алгоритма: На первом этапе на основании матрицы смежности строится граф <math>G = (V, E)</math> <math>k</math> ближайших соседей, где <math>V</math> - множество вершин графа (т.е. объекты), а <math>E</math> - множество ребер графа (т.е. построенные связи между ближайшими соседями). Указанный граф не обязательно является связным.

Второй этап алгоритма: Граф <math>G = (V, E)</math> итеративно разбивается на множество подграфов <math>G_{i} = (V_{i}, E_{i}), i = 1 .. m</math>, где <math> \cup V_{i} = V, i = 1 .. m</math>. Параметр <math>m</math> явно не задаётся, выполнение этого этапа алгоритма прекращается по выполнении описанных далее условий. На каждой итерации выбирается <math>G_{b}</math> с числом вершин, наибольшим среди всех подграфов, имеющихся на данной итерации. Этот граф разбивается на 2 подграфа <math>G_{bi}</math> и <math>G_{bj}</math> таких, что 1) <math>min(V_{bi},V_{bj}) >= 0.25 * V_{b}</math> (имеется ввиду количество вершин) и 2) <math>\sum{E_{kl}}, E_{kl} = (v_{k}, v_{l}), v_{k} \in V_{bi} , v_{l} \in V_{bj} </math> минимальна среди всех разбиений, удовлетворяющих 1). Итеративный процесс прекращается, когда <math>\sum{v_{b}} <= q * \sum{v} , v_{b} \in V_{b} , e \in E</math> (имеется ввиду количество вершин). Здесь <math>q</math> - задаваемый параметр, на практике он варьируется от <math>0.01</math> до <math>0.05</math>. Полученные подграфы называются малыми кластерами.

Третий этап алгоритма: Множество кластеров <math>G_{i} = (V_{i}, E_{i}), i = 1 .. m</math> итеративно преобразуется в множество кластеров <math>G_{j} = (V_{j}, E_{j}), j = 1 .. l</math>, <math>l <= m</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>S_{EC_{(C_{i},C_{j})}}</math> - абсолютное взаимное сходство пары кластеров <math>C_{i}, C{j}</math>. Это суть среднее сходство между соединенными вершинами, принадлежащими <math>C{i}</math> и <math>C{j}</math> соответственно. Соединения обусловлены разбиением общего графа, полученного на первом этапе алгоритма. 
<math>RI_{(C_{i},C_{j})} = \frac{2*|EC_{(C_{i},C_{j})}|}{|EC_{C_{i}}|+|EC_{C_{j}}|}</math> - относительная взаимная связность пары кластеров <math>C_{i}, 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>C{i}, C{j}</math> проверяется истинность выражений <math>RI_{(C_{i},C_{j})} >= T_{RI}</math> и <math>RC_{(C_{i},C_{j})} >= T_{RC}</math>, где <math>T_{RI}, T_{RI}</math> - заранее заданные пороговые значения. Если для некоторого <math>C_{i}</math> таких <math>C_{j}</math> несколько, то конкретная пара определяется по максимуму значения <math>EC_{(C_{i},C_{j})}</math>. Во втором случае выбираются пары кластеров, максимизирующие функцию вида <math>RI_{(C_{i},C_{j})}*RC_{(C_{i},C_{j})}^\alpha</math>. Здесь <math>\alpha</math> - заданный пользователем параметр. В обоих случаях процесс останавливается либо когда на очередной итерации не находится подходящих пар кластеров, либо когда остаётся только один кластер.

Вычисляемые данные: В процессе агломеративной кластеризации для всех объектов, т.е. всех вершин всех кластеров указывается индекс <math>j</math> кластера, к которому они принадлежат. После завершения алгоритма возможно перенумеровать кластеры. В любом случае на выходе будет иметься <math>n</math> значений, так как число объектов в процессе работы алгоритма не изменялось.

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

На первом этапе алгоритма основная вычислительная нагрузка приходится на анализ матрицы смежности, необходимого для построения первоначального графа <math>G = (V, E)</math>, так как для каждого объекта необходимо перебрать всех его соседей и выделить <math>k</math> ближайших по заданной метрике.

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

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

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

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

Схема представлена в виде C++-подобного псевдокода, макрооперации в алгоритме выделены в соответствии с предыдущим разделом описания.

<source lang="C++">
// First stage.
int k // Number of neighbors.
float v[n][p] // Initial vectors.
float M[n][n] // Adjacency matrix.
for (int i = 0; i < n; ++i) {
for (int l = 0; l < n; ++l) {
M[i][l] = Compute_metric(v[i],v[l]);
}
}
Graph max_graph // Structure/class that represents a graph.
Neighbor_list list // Here neighbors are initially stored.
max_graph.add_vertices // Vertices ~ initial vectors.
for (int i = 0; i < n; ++i) {
for (int l = i + 1; i < n; ++i) { // "Smart" version - we do not repeat same vertex combinations.
if (neighbor_number < k) {
add_neighbor(v[i],v[l]) // Just add.
}else{
substitute_neighbor(v[i],v[l]) // Check whether a new element is closer than some of the oldies.
}
}
max_graph.add_neighbors // Looks at neighbor lists of current vector and adds them
}
</source>

<source lang="C++">
// Second stage.
float percent // Determines when to stop splitting graphs.
Graph graphs[n] // GRAPHS WILL MOST LIKELY TAKE LESS SPACE, IT'S JUST THE UPPER LIMIT.
max_graph = find_max_graph() // Biggest graph by number of vertices available.
while (graph_size(max_graph) > n * percent) {
Split_graph(max_graph); // Split the graph - a macro operation that represents the second phase.
}
</source>

<source lang="C++">
// Third stage.
Graph graphs[m] // That's how many graphs we got. m <= n.
bool pairs_exist // Check if the're pairs of clusters to unite.
while (num_graphs > 1 && pairs_exist){
pairs_exist = false // So we don't repeat if it fails.
for (int i = 0; i < m; ++i) {
for (int l = i + 1; l < m; ++l) { // Also a "Smart" version.
check_pair(pairs_exist, graphs[i], graphs[l]); // Check whether graphs are similar enough by some metrics.
if (pairs_exist) { Unite_graphs(graphs[i], graphs[l]) }; // Pairs_exist is set to true if something's found.
}
}
}
</source>

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

Общая временная сложность последовательного варианта алгоритма CHAMELEON определяется как <math>O(nm + nlog{n} + mlog{m})</math>, где <math>n</math> - число исходных объектов, <math>m</math> - число малых кластеров, полученных после первого этапа работы. В случае "предельного" разбиения <math>m = n</math> эта оценка превращается в <math>O(n^2)</math>. В любом случае эта оценка не учитывает необходимости построения матрицы смежности по исходному набору векторов (авторы оригинальной статьи в своих исследованиях подразумевают, что матрица смежности уже построена), что означает дополнительные <math>O(n^2)</math> операций. Тогда оценка будет составлять <math>O(n^2 + nm + nlog{n} + mlog{m})</math> операций или <math>O(n^2)</math> в случае "предельного" разбиения.
Следует также обратить внимание, что это оценка по числу не сложений и умножений, а достаточно крупных операций. Например, вычисление метрики между двумя векторами рассматривается как одна операция, а она включает в себя <math>n</math> умножений и <math>2n</math> сложений (для вычисления квадратичной нормы разности векторов).

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

Информационный граф дан в соответствии с макроструктурой алгоритма. Следует отметить, что имеются успешные попытки распараллелить 2 и 3 этапы алгоритма CHAMELEON (см. раздел "Существующие реализации"). Однако они включают в себя модификацию исходного алгоритма. Также возможно распараллеливание выборки пар кластеров и подсчёта их метрик внутри каждой из вершин stage_3_iter. Структура информационного графа внутри этих итераций аналогична структуре информационного графа первого этапа алгоритма.

[[File:CHAMELEON ruslanlazovskiy.png]]

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

Параллельную сложность алгоритма CHAMELEON следует оценивать отдельно для каждого этапа.
На первом этапе алгоритм поиска <math>k</math> ближайших соседей может быть выполнен за <math>n - 1</math> вычислений значения метрики между двумя векторами.
На втором этапе итерации алгоритма выполняются строго последовательно, а распараллеливание алгоритма внутри итерации не относится к теме статьи.
На третьем этапе итерации также выполняются последовательно, однако возможно распараллеливание обработки пар кластеров внутри итерации. Каждая итерация может быть выполнена за <math>q - 1</math> вычислений значения метрики между двумя кластерами, где q - количество кластеров на этой итерации.

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

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

<math>O</math> - набор из <math>n</math> векторов длины <math>p</math>. 
<math>k</math> - число, определяющиее количество ближайших соседей, по которым строится первоначальный граф. 

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

<math>B</math> - вектор длины <math>n</math>, значение <math>i</math>-го элемента указывает на принадлежность соответствующего вектора одному из кластеров.

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

Соотношение последовательной и параллельной сложности: Различные этапы алгоритма строго последовательны относительно друг друга. На первом этапе отношение последовательной сложности алгоритма к параллельной есть <math>n/2</math>. На втором и третьем этапах различные итерации последовательны относительно друг друга. Однако внутри итераций допускается некоторый параллелизм. Например, для итераций третьего этапа в наилучшем случае отношение сложности последовательной реализации к параллельной есть <math>q/2</math>, где <math>q</math> - число кластеров на конкретной итерации.

Вычислительная мощность: графовые алгоритмы, вообще говоря, обладают низкой вычислительной мощностью. В случае CHAMELEON вычислительная мощность первого этапа равна <math>O(1)</math>. Для второго и третьего этапов оценка вычислительной мощности по сложениям и умножениям затруднительна, однако в терминах макроопераций можно дать грубую оценку. Вычислительная мощность каждой итерации второго этапа - <math>1 / \sum C_n^k</math>, где <math>n</math> - число вершин в выбранном подграфе, а <math>k</math> варьируется от <math>0.25 * n</math> до <math>0.5 * n</math>. Вычислительная мощность каждой итерации третьего этапа в этих терминах - <math>O(1)</math>.

Детерминированность: Важной особенностью описываемого алгоритма является его недетерминированность. Условия завершения как 2-го, так и 3-го этапа позволяют обозначить CHAMELEON как итерационный алгоритм с выходом по точности. При этом детерминированность 2-го этапа алгоритма можно обеспечить указанием вырожденных условий кластеризации (такая кластеризация, очевидно, не будет иметь практического смысла), в то время как 2-ый этап является недетерминированным всегда.

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

Как можно увидеть из раздела "существующие реализации", параллельной реализации алгоритма CHAMELEON на система с распределенной памятью найдено не было. Однако в <ref name = "exp">Parallel Algorithm for the Chameleon Clustering Algorithm using Dynamic Modeling. Rajnish Dashora, Harsh Bajaj, Akshat Dube, Geetha Mary .A. VIT University,Vellore. International Journal of Computer Applications (0975 – 8887) Volume 79 – No8, October 2013 </ref>. приводится экспериментальный вариант параллельной реализации посредством OpenMP для систем с общей памятью, включающий в себя значительную модификацию исходного алгоритма, но не приводится рабочая реализация.

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

Для исследования такой масштабируемости вширь использовалась референсная последовательная реализация алгоритма (cм. раздел "Существующие реализации"). Соответствующая программа запускалась на системе BG/P на одном вычислительном узле. Характеристики вычислительного узла, а также микропроцессорного ядра - элемента такого узла, приводятся в <ref>http://hpc.cmc.msu.ru/bgp</ref> Таким образом, удостоверенными экспериментальными данными являются только значения, полученные для случая 1 процесса. Значения для случаев 2 и 4 процессов являются ОЦЕНОЧНЫМИ и выводятся из результатов работы модифицированной версии алгоритма, исследуемой в <ref name = "exp">Parallel Algorithm for the Chameleon Clustering Algorithm using Dynamic Modeling. Rajnish Dashora, Harsh Bajaj, Akshat Dube, Geetha Mary .A. VIT University,Vellore. International Journal of Computer Applications (0975 – 8887) Volume 79 – No8, October 2013 </ref>. К сожалению, указанной реализации авторы не предоставляют.

[[File:CHAMELEON performance.png|800px]]

===Динамические характеристики и эффективность реализации алгоритма===
===Выводы для классов архитектур===
===Существующие реализации алгоритма===
С копией референсной реализации иерархической кластеризации, взятой с данного ресурса [http://us.codeforge.com/article/192925 Sequental], в случае неработоспособности последнего, можно ознакомиться здесь [http://pastebin.com/PhC4X0Cy Copy] 
Последовательная реализация алгоритма CHAMELEON использовалась в статье <ref>Clustering Of Web Usage Data Using
Chameleon Algorithm, T.Vijaya Kumar, Dr. H.S.Guruprasad, International Journal of Innovative Research in Computer
and Communication Engineering, Vol. 2, Issue 6, June 2014</ref>
Теоретически возможна реализация алгоритма CHAMELEON с использованием графовых библиотек, например [http://glaros.dtc.umn.edu/gkhome/metis/metis/overview METIS ], [http://glaros.dtc.umn.edu/gkhome/metis/hmetis/overview hMETIS] и [https://cran.r-project.org/web/packages/RANN/index.html RANN]. 
Параллельных реализаций алгоритма CHAMELEON в графовых библиотеках мною найдено не было. Однако существует исследование, связанное с реализацией CHAMELEON посредством технологии OpenMP, с которым можно ознакомиться здесь [http://research.ijcaonline.org/volume79/number8/pxc3891600.pdf параллельная реализация].

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

<references \>

Краткий обзор алгоритма [http://studopedia.ru/7_41934_algoritm-dinamicheskoy-ierarhicheskoy-klasterizatsii-CHAMELEON.html|] 
Первоначальная статья от авторов алгоритма [http://www-users.cs.umn.edu/~han/dmclass/chameleon.pdf|] 
Исследования возможной параллелизации алгоритма[http://research.ijcaonline.org/volume79/number8/pxc3891600.pdf|]

Участник:Ruslanlazovskiy/CHAMELEON

2017-01-25T12:19:25Z

Hromovalexander: /* Программная реализация алгоритма */

{{Assignment|Algoman|Kronberg}}

{{algorithm
| name = CHAMELEON
| serial_complexity = <math>O(n*m + n*log{n} + m*log{m})</math>
| pf_height = <math>O(n)</math> - этап 1. <math>O(q)</math> - отдельная итерация этапа 3.
| pf_width = <math>O(n)</math> - этап 1. <math>O(q)</math> - отдельная итерация этапа 3.
| input_data = <math>n^2 / 2</math>
| output_data = <math>n</math>
}}

Авторы статьи:
[https://algowiki-project.org/ru/%D0%A3%D1%87%D0%B0%D1%81%D1%82%D0%BD%D0%B8%D0%BA:Ruslanlazovskiy Лазовский Р. А.] (разделы 1.1 - 1.4 , 1.7 , 1.8),
[https://algowiki-project.org/ru/%D0%A3%D1%87%D0%B0%D1%81%D1%82%D0%BD%D0%B8%D0%BA:%D0%9C%D1%83%D1%81%D1%82%D0%B0%D1%84%D0%B0%D0%B5%D0%B2_%D0%AD%D0%BB%D1%8C%D0%B2%D0%B8%D0%BD_%D0%AD%D0%BB%D1%8C%D0%BC%D0%B0%D0%BD%D0%BE%D0%B2%D0%B8%D1%87 Мустафаев Э. Э.] (разделы 1.5 , 1.6 , 1.9 , 1.10 , 2.2)

==Свойства и структура алгоритма==
===Общее описание алгоритма===
CHAMELEON – алгоритм динамической иерархической кластеризации графа, то есть процесса разбиения графа на несколько подграфов-кластеров таким образом, что данные внутри одного кластера имеют максимально схожи, а данные в разных кластерах — максимально различны. В классических алгоритмах кластеризации схожесть объектов определяется с помощью некоторой метрики (простейший пример — евклидова метрика). Не следует путать задачу кластеризации с задачей классификации: в последней характеристики объекта, необходимые для попадания в тот или иной класс, известны заранее, в рассматриваемой же задаче они становятся известны в процессе решения. Первоначально алгоритм был описан в статье<ref>CHAMELEON: A Hierarchical Clustering Algorithm Using Dynamic Modeling. George Karypis, Eui-Hong Han, Vipin Kumar. IEEE Computer 32(8): 68-75, 1999</ref>.

Алгоритм CHAMELEON работает в 3 этапа. На первом этапе исходное множество объектов организуется в граф по принципу k ближайших соседей. На втором этапе этого граф разбивается на достаточно малые подграфы-кластеры. На третьем этапе происходит агломеративная иерархическая кластеризация полученных подграфов в соответствии с одной из выбранных метрик (возможные метрики будут подробно описаны далее). Число получаемых в итоге кластеров в явном виде не задаётся.

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

Исходные данные: Первоначально исходными данными алгоритма являются <math>n</math> векторов длины <math>p</math>, каждый из которых соответствует одному объекту. На основании значений элементов этих векторов строится матрица смежности размера <math>n * n</math>, возможно сокращение требуемого объема памяти до <math>(n*(n - 1))/ 2</math> в соответствии с выбранной метрикой. К исходным данным также относится набор параметров. Это <math>k</math> - количество ближайших соседей на первом этапе алгоритма, <math>q</math> - отношение количества вершин в наибольшем подграфе по отношению к общему числу объектов на втором этапе алгоритма, а также параметры <math>T_{RI}, T_{RI}</math> - пороговые значения, после которых прекращается агломеративная кластеризация на третьем этапе. Следует особо отметить, что число получаемых в итоге кластеров заранее не известно, хотя на него и можно повлиять изменением значений перечисленных параметров.

Первый этап алгоритма: На первом этапе на основании матрицы смежности строится граф <math>G = (V, E)</math> <math>k</math> ближайших соседей, где <math>V</math> - множество вершин графа (т.е. объекты), а <math>E</math> - множество ребер графа (т.е. построенные связи между ближайшими соседями). Указанный граф не обязательно является связным.

Второй этап алгоритма: Граф <math>G = (V, E)</math> итеративно разбивается на множество подграфов <math>G_{i} = (V_{i}, E_{i}), i = 1 .. m</math>, где <math> \cup V_{i} = V, i = 1 .. m</math>. Параметр <math>m</math> явно не задаётся, выполнение этого этапа алгоритма прекращается по выполнении описанных далее условий. На каждой итерации выбирается <math>G_{b}</math> с числом вершин, наибольшим среди всех подграфов, имеющихся на данной итерации. Этот граф разбивается на 2 подграфа <math>G_{bi}</math> и <math>G_{bj}</math> таких, что 1) <math>min(V_{bi},V_{bj}) >= 0.25 * V_{b}</math> (имеется ввиду количество вершин) и 2) <math>\sum{E_{kl}}, E_{kl} = (v_{k}, v_{l}), v_{k} \in V_{bi} , v_{l} \in V_{bj} </math> минимальна среди всех разбиений, удовлетворяющих 1). Итеративный процесс прекращается, когда <math>\sum{v_{b}} <= q * \sum{v} , v_{b} \in V_{b} , e \in E</math> (имеется ввиду количество вершин). Здесь <math>q</math> - задаваемый параметр, на практике он варьируется от <math>0.01</math> до <math>0.05</math>. Полученные подграфы называются малыми кластерами.

Третий этап алгоритма: Множество кластеров <math>G_{i} = (V_{i}, E_{i}), i = 1 .. m</math> итеративно преобразуется в множество кластеров <math>G_{j} = (V_{j}, E_{j}), j = 1 .. l</math>, <math>l <= m</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>S_{EC_{(C_{i},C_{j})}}</math> - абсолютное взаимное сходство пары кластеров <math>C_{i}, C{j}</math>. Это суть среднее сходство между соединенными вершинами, принадлежащими <math>C{i}</math> и <math>C{j}</math> соответственно. Соединения обусловлены разбиением общего графа, полученного на первом этапе алгоритма. 
<math>RI_{(C_{i},C_{j})} = \frac{2*|EC_{(C_{i},C_{j})}|}{|EC_{C_{i}}|+|EC_{C_{j}}|}</math> - относительная взаимная связность пары кластеров <math>C_{i}, 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>C{i}, C{j}</math> проверяется истинность выражений <math>RI_{(C_{i},C_{j})} >= T_{RI}</math> и <math>RC_{(C_{i},C_{j})} >= T_{RC}</math>, где <math>T_{RI}, T_{RI}</math> - заранее заданные пороговые значения. Если для некоторого <math>C_{i}</math> таких <math>C_{j}</math> несколько, то конкретная пара определяется по максимуму значения <math>EC_{(C_{i},C_{j})}</math>. Во втором случае выбираются пары кластеров, максимизирующие функцию вида <math>RI_{(C_{i},C_{j})}*RC_{(C_{i},C_{j})}^\alpha</math>. Здесь <math>\alpha</math> - заданный пользователем параметр. В обоих случаях процесс останавливается либо когда на очередной итерации не находится подходящих пар кластеров, либо когда остаётся только один кластер.

Вычисляемые данные: В процессе агломеративной кластеризации для всех объектов, т.е. всех вершин всех кластеров указывается индекс <math>j</math> кластера, к которому они принадлежат. После завершения алгоритма возможно перенумеровать кластеры. В любом случае на выходе будет иметься <math>n</math> значений, так как число объектов в процессе работы алгоритма не изменялось.

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

На первом этапе алгоритма основная вычислительная нагрузка приходится на анализ матрицы смежности, необходимого для построения первоначального графа <math>G = (V, E)</math>, так как для каждого объекта необходимо перебрать всех его соседей и выделить <math>k</math> ближайших по заданной метрике.

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

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

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

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

Схема представлена в виде C++-подобного псевдокода, макрооперации в алгоритме выделены в соответствии с предыдущим разделом описания.

<source lang="C++">
// First stage.
int k // Number of neighbors.
float v[n][p] // Initial vectors.
float M[n][n] // Adjacency matrix.
for (int i = 0; i < n; ++i) {
for (int l = 0; l < n; ++l) {
M[i][l] = Compute_metric(v[i],v[l]);
}
}
Graph max_graph // Structure/class that represents a graph.
Neighbor_list list // Here neighbors are initially stored.
max_graph.add_vertices // Vertices ~ initial vectors.
for (int i = 0; i < n; ++i) {
for (int l = i + 1; i < n; ++i) { // "Smart" version - we do not repeat same vertex combinations.
if (neighbor_number < k) {
add_neighbor(v[i],v[l]) // Just add.
}else{
substitute_neighbor(v[i],v[l]) // Check whether a new element is closer than some of the oldies.
}
}
max_graph.add_neighbors // Looks at neighbor lists of current vector and adds them
}
</source>

<source lang="C++">
// Second stage.
float percent // Determines when to stop splitting graphs.
Graph graphs[n] // GRAPHS WILL MOST LIKELY TAKE LESS SPACE, IT'S JUST THE UPPER LIMIT.
max_graph = find_max_graph() // Biggest graph by number of vertices available.
while (graph_size(max_graph) > n * percent) {
Split_graph(max_graph); // Split the graph - a macro operation that represents the second phase.
}
</source>

<source lang="C++">
// Third stage.
Graph graphs[m] // That's how many graphs we got. m <= n.
bool pairs_exist // Check if the're pairs of clusters to unite.
while (num_graphs > 1 && pairs_exist){
pairs_exist = false // So we don't repeat if it fails.
for (int i = 0; i < m; ++i) {
for (int l = i + 1; l < m; ++l) { // Also a "Smart" version.
check_pair(pairs_exist, graphs[i], graphs[l]); // Check whether graphs are similar enough by some metrics.
if (pairs_exist) { Unite_graphs(graphs[i], graphs[l]) }; // Pairs_exist is set to true if something's found.
}
}
}
</source>

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

Общая временная сложность последовательного варианта алгоритма CHAMELEON определяется как <math>O(nm + nlog{n} + mlog{m})</math>, где <math>n</math> - число исходных объектов, <math>m</math> - число малых кластеров, полученных после первого этапа работы. В случае "предельного" разбиения <math>m = n</math> эта оценка превращается в <math>O(n^2)</math>. В любом случае эта оценка не учитывает необходимости построения матрицы смежности по исходному набору векторов (авторы оригинальной статьи в своих исследованиях подразумевают, что матрица смежности уже построена), что означает дополнительные <math>O(n^2)</math> операций. Тогда оценка будет составлять <math>O(n^2 + nm + nlog{n} + mlog{m})</math> операций или <math>O(n^2)</math> в случае "предельного" разбиения.
Следует также обратить внимание, что это оценка по числу не сложений и умножений, а достаточно крупных операций. Например, вычисление метрики между двумя векторами рассматривается как одна операция, а она включает в себя <math>n</math> умножений и <math>2n</math> сложений (для вычисления квадратичной нормы разности векторов).

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

Информационный граф дан в соответствии с макроструктурой алгоритма. Следует отметить, что имеются успешные попытки распараллелить 2 и 3 этапы алгоритма CHAMELEON (см. раздел "Существующие реализации"). Однако они включают в себя модификацию исходного алгоритма. Также возможно распараллеливание выборки пар кластеров и подсчёта их метрик внутри каждой из вершин stage_3_iter. Структура информационного графа внутри этих итераций аналогична структуре информационного графа первого этапа алгоритма.

[[File:CHAMELEON ruslanlazovskiy.png]]

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

Параллельную сложность алгоритма CHAMELEON следует оценивать отдельно для каждого этапа.
На первом этапе алгоритм поиска <math>k</math> ближайших соседей может быть выполнен за <math>n - 1</math> вычислений значения метрики между двумя векторами.
На втором этапе итерации алгоритма выполняются строго последовательно, а распараллеливание алгоритма внутри итерации не относится к теме статьи.
На третьем этапе итерации также выполняются последовательно, однако возможно распараллеливание обработки пар кластеров внутри итерации. Каждая итерация может быть выполнена за <math>q - 1</math> вычислений значения метрики между двумя кластерами, где q - количество кластеров на этой итерации.

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

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

<math>O</math> - набор из <math>n</math> векторов длины <math>p</math>. 
<math>k</math> - число, определяющиее количество ближайших соседей, по которым строится первоначальный граф. 

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

<math>B</math> - вектор длины <math>n</math>, значение <math>i</math>-го элемента указывает на принадлежность соответствующего вектора одному из кластеров.

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

Соотношение последовательной и параллельной сложности: Различные этапы алгоритма строго последовательны относительно друг друга. На первом этапе отношение последовательной сложности алгоритма к параллельной есть <math>n/2</math>. На втором и третьем этапах различные итерации последовательны относительно друг друга. Однако внутри итераций допускается некоторый параллелизм. Например, для итераций третьего этапа в наилучшем случае отношение сложности последовательной реализации к параллельной есть <math>q/2</math>, где <math>q</math> - число кластеров на конкретной итерации.

Вычислительная мощность: графовые алгоритмы, вообще говоря, обладают низкой вычислительной мощностью. В случае CHAMELEON вычислительная мощность первого этапа равна <math>O(1)</math>. Для второго и третьего этапов оценка вычислительной мощности по сложениям и умножениям затруднительна, однако в терминах макроопераций можно дать грубую оценку. Вычислительная мощность каждой итерации второго этапа - <math>1 / \sum C_n^k</math>, где <math>n</math> - число вершин в выбранном подграфе, а <math>k</math> варьируется от <math>0.25 * n</math> до <math>0.5 * n</math>. Вычислительная мощность каждой итерации третьего этапа в этих терминах - <math>O(1)</math>.

Детерминированность: Важной особенностью описываемого алгоритма является его недетерминированность. Условия завершения как 2-го, так и 3-го этапа позволяют обозначить CHAMELEON как итерационный алгоритм с выходом по точности. При этом детерминированность 2-го этапа алгоритма можно обеспечить указанием вырожденных условий кластеризации (такая кластеризация, очевидно, не будет иметь практического смысла), в то время как 2-ый этап является недетерминированным всегда.

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

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

<references \>

Краткий обзор алгоритма [http://studopedia.ru/7_41934_algoritm-dinamicheskoy-ierarhicheskoy-klasterizatsii-CHAMELEON.html|] 
Первоначальная статья от авторов алгоритма [http://www-users.cs.umn.edu/~han/dmclass/chameleon.pdf|] 
Исследования возможной параллелизации алгоритма[http://research.ijcaonline.org/volume79/number8/pxc3891600.pdf|]

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

2017-01-25T09:37:05Z

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

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

2017-01-25T09:36:32Z

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

{{В инкубаторе}}
== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===
Алгоритм CHAMELEON - алгоритм динамической иерархической кластеризации графа.

Кластеризация - разбиение графа на несколько подграфов таким образом, чтобы объекты внутри одного кластера были максимально близки (схожи), а данные двух различных кластеров максимально различались. Различие и схожесть объектов определяются некоей метрикой, известной заранее. Количество кластеров, на которые будет разбит граф, заранее неизвестно, и зависит от свойств объекта и выбранной метрики. Простейшей возможной метриков является расстояние между точками (если предполагать, что у каждой вершины графа есть координаты).

Алгоритм состоит из 3-х основных этапов:

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

2-й этап заключается в разбиении построенного графа на небольшие кластеры (связные подграфы)

3-й этап состоит в формировании итогового множества кластеров

=== Математическое описание алгоритма ===
'''Исходные данные'''

Множество из n объектов и заданные расстояния между объектами. Эта информация позволяет построить матрицу смежности, в которой будут указаны расстояния между соответствующими объектами по некой метрике. Матрица смежности симметрична, на главной диагонали стоят 0, поэтому достаточно хранить <math>\frac{n(n-1)}{2}</math> элементов. Кроме того задаются параметры, влияющие на работу алгоритма - число k, по которому на первом этапе строится граф по принципу k ближайших соседей, и два параметра <math>{T_{ri}}</math> и <math>{T_{rc}}</math>, используемые на третьем этапе для того, что определить, что не нужно далее продолжать кластеризацию.

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

На первом этапе строится граф <math>G(V,E)</math>, <math>V</math> - множество вершин, <math>E</math> - множество ребер, по принципу k ближайших соседей. Изначально граф состоит из множества вершин и пустого множества ребер. Для каждой вершины графа мы выбираем k других вершин, расстояния до которых минимальны (то есть k первых вершин в списке вершин графа, упорядоченных по увеличению расстояния до данной) и добавляем в множество ребер соответствующие ребра, соединяющие данную вершину с каждой из выбранных k вершин.

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

Состоит в итеративном разбиении графа на множество подграфов. Изначально (на первой итерации) разбиение состоит из единственного подграфа. Пусть <math>T</math> - множество подграфов на текущей итерации. Каждая итерация выполняется следующим образом - выбирается максимальный подграф из имеющихся в разбиении по числу вершин (то есть такой подграф <math>G_1(V_1,E_1)\in{T}: \forall {G_2(V_2,E_2)\in{T}: G_2\neq G_1} => |(V_1)|>|(V_2)|</math> ). Выбранный подграф разбивается на 2 подграфа следующим образом - сначала выбираются все разбиения <math>G_2(V_2,E_2)</math> и <math>G_3(V_3,E_3)</math>, такие, что <math>\min(|V_2|,|V_3|)\geq\frac{|V_1|}{4}</math>. Далее среди всех таких разбиений выбирается такое, для которого величина <math>\sum{|E_1^*|},E_1^* </math>- некое ребро, ведущее из вершины, попавшей в <math>G_2</math> в вершину, попавшую в <math>G_3</math>. В определенный момент, когда размер наибольшего кластера <math>|V_b|\leq{q*|V|}</math>, где <math>|V|</math> - количество вершин в изначальном графе, а <math>q</math> - предварительно заданный параметр, процесс дальнейшего разибения прекращается и алгоритм переходи на 3-й этап

'''Третий этап алгоритма:'''

Введем несколько определений:

Абсолютной взаимной связностью пары кластеров называется величина <math>EC_{({C_i},{C_j})}</math>, вычисляется как сумма весов ребер, соединяющих вершина 1-го кластера <math>C_i</math> с вершинами второго кластера <math>C_j</math>. Внутренняя связность кластера <math>E_{C_i}</math>вычисляется как сумма весов ребер, входящих в разделитель, разбивающих <math>C_i</math> на 2 равных подграфа.

Относительная взаимная связность пары кластеров <math>RI_{(C_i,C_j)}</math> вычисляется по формуле <math>RI_{(C_i,C_j)}=\frac{2*|EC_{(C_i,C_j)}|}{|EC_{C_i}|+|EC_{C_j}|}</math>

Абсолютное взаимное сходство пары кластеров <math>S_{E_{(C_i,C_j)}}</math>вычисляется как среднее сходство между связанными вершинами <math>C_i</math> и <math>C_j</math>

Относительное взаимное сходство пары кластеров <math>C_i</math> и <math>C_j</math> обозначается <math>RC_{(C_i,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_j|}{|C_i|+|C_j|}*S_{EC_{(C_j)}}}}</math>

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

Есть два различных подхода анализа сходства.

Первый - для каждой пары кластеров проверяется истинность следующих высказываний

<math>RI(Ci,Cj)\geq{T_{RI}} </math> и <math>RC_{(C_{i},C_{j})}\geq{T_{RC}}</math>

В случае, если для некоторого <math>C_i</math> существует несколько кластеров <math>C_j</math>, удовлетворяющих этим условиям, выбирается такой <math>C_j</math>, что

значение <math>EC_{(C_i,C_j)}</math> максимально.

Процесс останавливается, когда нет кластеров, удовлетворяющих указанным условиям (либо когда остался только 1 кластер)

Второй подход - выбирается такая пара кластеров, что <math>RI_{(C_i,C_j)}*RC^\alpha_{(C_i,C_j)}</math> максимально, где <math>\alpha</math> - заданный заранее параметр.

Процесс останавливается, когда нет кластеров, удовлетворяющих указанным условиям (либо когда остался только 1 кластер)

=== Вычислительное ядро алгоритма ===
На первом этапе вычислительное ядро состоит из построения графа k ближайших соседей по исходной матрице смежности (требуется для каждой вершины перебрать всех соседей и выделить k ближайших)

На втором этапе вычислительное ядро состоит из повторяющегося нахождения разбиения графа на два подграфа, удовлетворяющего ранее описанным условиям

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

=== Макроструктура алгоритма ===
В рамках первого этапа макрооперацияй считается построение графа k-ближайших соседей

В рамках второго этапа макрооперациями считаются операции разбиения подграфа.

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

=== Схема реализации последовательного алгоритма ===
Схема представлена в виде C++-подобного псевдокода, макрооперации в алгоритме выделены в соответствии с предыдущим разделом описания.
int n; // Количество точек.
int k; // Параметр k
int Dist[n][n]; // Матрица расстояний между точками.

integer E[n][n]; // Матрица рёбер графа

foreach (int i=0; i<n; i++) ) {
integer KNeighbours[k]; // список, используемый для хранения ближайших соседей
integer countN = 0;

foreach (int j=i+1; j<n; j++ ) {
//Заполняем список k ближайших соседей по матрице Dist
}

foreach (int j=0; j<k; j++) {
E[i][KNeighbours[j]] = 1;
}
}
return E;

double q; //Параметр, описание находится в соответствующем разделе.
Graph g = getBiggestGraph(); //Находим граф максимального размера
int maxSize = getSize(g); //Находим размер данного графа
while (maxSize > n * q) {
breakGraph(g); // Разбиваем граф
}

Graph graphs[m]; //Разбиение по кластерам
while (count(graphs)>1){
pairs_exist = false //Значение будет обновлено позже, если найдется подходящая пара для объединения
for (int i = 0; i < m; i++) {
for (int j = i + 1; j < m; j++) {
if (checkSimilarity(graphs[i],graphs[j])) { //Проверяем, достаточно ли схожи графы для объединения
unite(graphs[i], graphs[l])
} else {
break;
}
}
}
}

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

На втором этапе для итеративного разбиения требуется <math>O(nm)</math>операций, где <math>n</math> - количество вершин графа, а <math>m</math> - количество подграфов в итоговом разбиении.

На третьем этапе требуется <math>O(m^2logm)</math> операций, причем вычисление метрики считается за одну операцию.

Итоговая оценка последовательной сложности <math>O(n^2)+O(nm)+O(m^2logm)</math>

=== Информационный граф ===
[[Файл:Инфограф.png]]

=== Ресурс параллелизма алгоритма ===
На первом этапе вычисление <math>k</math> ближайших вершин для <math>i</math>-й вершины можно распараллелить между <math>n</math> процессами (это вычисление независимо для каждой вершины).
На втором и третьем этапах процессы разбиения и объединения подграфов происходят последовательно.
Получаем оценку параллельной сложности алгоритма <math>O(nm)+O(m^2logm)</math>

=== Входные и выходные данные алгоритма ===
На вход алгоритму подается множество из <math>n</math> векторов длины <math>l</math>, описывающих объекты для кластеризации.
Также передаются параметры <math>k</math> (для построения графа k ближайших соседей на первом этапе) и <math>q</math> (используется на втором этапе для определения критерия прекращения итерационного процесса).
На выходе алгоритм выдает массив длины <math>n</math>, заполненный числами от <math>1<math/> до <math>n</math>, показывающими, в какой кластер попал соответствующий объект.

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

2017-01-25T09:30:10Z

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

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

2017-01-24T15:20:35Z

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

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

2017-01-24T15:18:19Z

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

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

2017-01-24T15:18:11Z

Hromovalexander:

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

2017-01-24T15:15:35Z

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

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

2017-01-24T14:19:00Z

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

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

2017-01-24T14:18:23Z

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

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

2017-01-24T14:17:20Z

Hromovalexander: /* 1.3 Вычислительное ядро алгоритма */

{{В инкубаторе}}
== 1 Свойства и структура алгоритма ==

=== Общее описание алгоритма ===
Алгоритм CHAMELEON - алгоритм динамической иерархической кластеризации графа.

Кластеризация - разбиение графа на несколько подграфов таким образом, чтобы объекты внутри одного кластера были максимально близки (схожи), а данные двух различных кластеров максимально различались. Различие и схожесть объектов определяются некоей метрикой, известной заранее. Количество кластеров, на которые будет разбит граф, заранее неизвестно, и зависит от свойств объекта и выбранной метрики. Простейшей возможной метриков является расстояние между точками (если предполагать, что у каждой вершины графа есть координаты).

Алгоритм состоит из 3-х основных этапов:

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

2-й этап заключается в разбиении построенного графа на небольшие кластеры (связные подграфы)

3-й этап состоит в формировании итогового множества кластеров

=== Математическое описание алгоритма ===
'''Исходные данные'''

Множество из n объектов и заданные расстояния между объектами. Эта информация позволяет построить матрицу смежности, в которой будут указаны расстояния между соответствующими объектами по некой метрике. Матрица смежности симметрична, на главной диагонали стоят 0, поэтому достаточно хранить <math>\frac{n(n-1)}{2}</math> элементов. Кроме того задаются параметры, влияющие на работу алгоритма - число k, по которому на первом этапе строится граф по принципу k ближайших соседей, и два параметра <math>{T_{ri}}</math> и <math>{T_{rc}}</math>, используемые на третьем этапе для того, что определить, что не нужно далее продолжать кластеризацию.

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

На первом этапе строится граф <math>G(V,E)</math>, <math>V</math> - множество вершин, <math>E</math> - множество ребер, по принципу k ближайших соседей. Изначально граф состоит из множества вершин и пустого множества ребер. Для каждой вершины графа мы выбираем k других вершин, расстояния до которых минимальны (то есть k первых вершин в списке вершин графа, упорядоченных по увеличению расстояния до данной) и добавляем в множество ребер соответствующие ребра, соединяющие данную вершину с каждой из выбранных k вершин.

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

Состоит в итеративном разбиении графа на множество подграфов. Изначально (на первой итерации) разбиение состоит из единственного подграфа. Пусть <math>T</math> - множество подграфов на текущей итерации. Каждая итерация выполняется следующим образом - выбирается максимальный подграф из имеющихся в разбиении по числу вершин (то есть такой подграф <math>G_1(V_1,E_1)\in{T}: \forall {G_2(V_2,E_2)\in{T}: G_2\neq G_1} => |(V_1)|>|(V_2)|</math> ). Выбранный подграф разбивается на 2 подграфа следующим образом - сначала выбираются все разбиения <math>G_2(V_2,E_2)</math> и <math>G_3(V_3,E_3)</math>, такие, что <math>\min(|V_2|,|V_3|)\geq\frac{|V_1|}{4}</math>. Далее среди всех таких разбиений выбирается такое, для которого величина <math>\sum{|E_1^*|},E_1^* </math>- некое ребро, ведущее из вершины, попавшей в <math>G_2</math> в вершину, попавшую в <math>G_3</math>. В определенный момент, когда размер наибольшего кластера <math>|V_b|\leq{q*|V|}</math>, где <math>|V|</math> - количество вершин в изначальном графе, а <math>q</math> - предварительно заданный параметр, процесс дальнейшего разибения прекращается и алгоритм переходи на 3-й этап

'''Третий этап алгоритма:'''

Введем несколько определений:

Абсолютной взаимной связностью пары кластеров называется величина <math>EC_{({C_i},{C_j})}</math>, вычисляется как сумма весов ребер, соединяющих вершина 1-го кластера <math>C_i</math> с вершинами второго кластера <math>C_j</math>. Внутренняя связность кластера <math>E_{C_i}</math>вычисляется как сумма весов ребер, входящих в разделитель, разбивающих <math>C_i</math> на 2 равных подграфа.

Относительная взаимная связность пары кластеров <math>RI_{(C_i,C_j)}</math> вычисляется по формуле <math>RI_{(C_i,C_j)}=\frac{2*|EC_{(C_i,C_j)}|}{|EC_{C_i}|+|EC_{C_j}|}</math>

Абсолютное взаимное сходство пары кластеров <math>S_{E_{(C_i,C_j)}}</math>вычисляется как среднее сходство между связанными вершинами <math>C_i</math> и <math>C_j</math>

Относительное взаимное сходство пары кластеров <math>C_i</math> и <math>C_j</math> обозначается <math>RC_{(C_i,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_j|}{|C_i|+|C_j|}*S_{EC_{(C_j)}}}}</math>

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

Есть два различных подхода анализа сходства.

Первый - для каждой пары кластеров проверяется истинность следующих высказываний

<math>RI(Ci,Cj)\geq{T_{RI}} </math> и <math>RC_{(C_{i},C_{j})}\geq{T_{RC}}</math>

В случае, если для некоторого <math>C_i</math> существует несколько кластеров <math>C_j</math>, удовлетворяющих этим условиям, выбирается такой <math>C_j</math>, что

значение <math>EC_{(C_i,C_j)}</math> максимально.

Процесс останавливается, когда нет кластеров, удовлетворяющих указанным условиям (либо когда остался только 1 кластер)

Второй подход - выбирается такая пара кластеров, что <math>RI_{(C_i,C_j)}*RC^\alpha_{(C_i,C_j)}</math> максимально, где <math>\alpha</math> - заданный заранее параметр.

Процесс останавливается, когда нет кластеров, удовлетворяющих указанным условиям (либо когда остался только 1 кластер)

=== Вычислительное ядро алгоритма ===
На первом этапе вычислительное ядро состоит из построения графа k ближайших соседей по исходной матрице смежности (требуется для каждой вершины перебрать всех соседей и выделить k ближайших)

На втором этапе вычислительное ядро состоит из повторяющегося нахождения разбиения графа на два подграфа, удовлетворяющего ранее описанным условиям

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

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

2017-01-24T14:17:12Z

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

{{В инкубаторе}}
== 1 Свойства и структура алгоритма ==

=== Общее описание алгоритма ===
Алгоритм CHAMELEON - алгоритм динамической иерархической кластеризации графа.

Кластеризация - разбиение графа на несколько подграфов таким образом, чтобы объекты внутри одного кластера были максимально близки (схожи), а данные двух различных кластеров максимально различались. Различие и схожесть объектов определяются некоей метрикой, известной заранее. Количество кластеров, на которые будет разбит граф, заранее неизвестно, и зависит от свойств объекта и выбранной метрики. Простейшей возможной метриков является расстояние между точками (если предполагать, что у каждой вершины графа есть координаты).

Алгоритм состоит из 3-х основных этапов:

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

2-й этап заключается в разбиении построенного графа на небольшие кластеры (связные подграфы)

3-й этап состоит в формировании итогового множества кластеров

=== Математическое описание алгоритма ===
'''Исходные данные'''

Множество из n объектов и заданные расстояния между объектами. Эта информация позволяет построить матрицу смежности, в которой будут указаны расстояния между соответствующими объектами по некой метрике. Матрица смежности симметрична, на главной диагонали стоят 0, поэтому достаточно хранить <math>\frac{n(n-1)}{2}</math> элементов. Кроме того задаются параметры, влияющие на работу алгоритма - число k, по которому на первом этапе строится граф по принципу k ближайших соседей, и два параметра <math>{T_{ri}}</math> и <math>{T_{rc}}</math>, используемые на третьем этапе для того, что определить, что не нужно далее продолжать кластеризацию.

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

На первом этапе строится граф <math>G(V,E)</math>, <math>V</math> - множество вершин, <math>E</math> - множество ребер, по принципу k ближайших соседей. Изначально граф состоит из множества вершин и пустого множества ребер. Для каждой вершины графа мы выбираем k других вершин, расстояния до которых минимальны (то есть k первых вершин в списке вершин графа, упорядоченных по увеличению расстояния до данной) и добавляем в множество ребер соответствующие ребра, соединяющие данную вершину с каждой из выбранных k вершин.

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

Состоит в итеративном разбиении графа на множество подграфов. Изначально (на первой итерации) разбиение состоит из единственного подграфа. Пусть <math>T</math> - множество подграфов на текущей итерации. Каждая итерация выполняется следующим образом - выбирается максимальный подграф из имеющихся в разбиении по числу вершин (то есть такой подграф <math>G_1(V_1,E_1)\in{T}: \forall {G_2(V_2,E_2)\in{T}: G_2\neq G_1} => |(V_1)|>|(V_2)|</math> ). Выбранный подграф разбивается на 2 подграфа следующим образом - сначала выбираются все разбиения <math>G_2(V_2,E_2)</math> и <math>G_3(V_3,E_3)</math>, такие, что <math>\min(|V_2|,|V_3|)\geq\frac{|V_1|}{4}</math>. Далее среди всех таких разбиений выбирается такое, для которого величина <math>\sum{|E_1^*|},E_1^* </math>- некое ребро, ведущее из вершины, попавшей в <math>G_2</math> в вершину, попавшую в <math>G_3</math>. В определенный момент, когда размер наибольшего кластера <math>|V_b|\leq{q*|V|}</math>, где <math>|V|</math> - количество вершин в изначальном графе, а <math>q</math> - предварительно заданный параметр, процесс дальнейшего разибения прекращается и алгоритм переходи на 3-й этап

'''Третий этап алгоритма:'''

Введем несколько определений:

Абсолютной взаимной связностью пары кластеров называется величина <math>EC_{({C_i},{C_j})}</math>, вычисляется как сумма весов ребер, соединяющих вершина 1-го кластера <math>C_i</math> с вершинами второго кластера <math>C_j</math>. Внутренняя связность кластера <math>E_{C_i}</math>вычисляется как сумма весов ребер, входящих в разделитель, разбивающих <math>C_i</math> на 2 равных подграфа.

Относительная взаимная связность пары кластеров <math>RI_{(C_i,C_j)}</math> вычисляется по формуле <math>RI_{(C_i,C_j)}=\frac{2*|EC_{(C_i,C_j)}|}{|EC_{C_i}|+|EC_{C_j}|}</math>

Абсолютное взаимное сходство пары кластеров <math>S_{E_{(C_i,C_j)}}</math>вычисляется как среднее сходство между связанными вершинами <math>C_i</math> и <math>C_j</math>

Относительное взаимное сходство пары кластеров <math>C_i</math> и <math>C_j</math> обозначается <math>RC_{(C_i,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_j|}{|C_i|+|C_j|}*S_{EC_{(C_j)}}}}</math>

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

Есть два различных подхода анализа сходства.

Первый - для каждой пары кластеров проверяется истинность следующих высказываний

<math>RI(Ci,Cj)\geq{T_{RI}} </math> и <math>RC_{(C_{i},C_{j})}\geq{T_{RC}}</math>

В случае, если для некоторого <math>C_i</math> существует несколько кластеров <math>C_j</math>, удовлетворяющих этим условиям, выбирается такой <math>C_j</math>, что

значение <math>EC_{(C_i,C_j)}</math> максимально.

Процесс останавливается, когда нет кластеров, удовлетворяющих указанным условиям (либо когда остался только 1 кластер)

Второй подход - выбирается такая пара кластеров, что <math>RI_{(C_i,C_j)}*RC^\alpha_{(C_i,C_j)}</math> максимально, где <math>\alpha</math> - заданный заранее параметр.

Процесс останавливается, когда нет кластеров, удовлетворяющих указанным условиям (либо когда остался только 1 кластер)

=== 1.3 Вычислительное ядро алгоритма ===
На первом этапе вычислительное ядро состоит из построения графа k ближайших соседей по исходной матрице смежности (требуется для каждой вершины перебрать всех соседей и выделить k ближайших)

На втором этапе вычислительное ядро состоит из повторяющегося нахождения разбиения графа на два подграфа, удовлетворяющего ранее описанным условиям

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

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

2017-01-24T14:16:49Z

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

{{В инкубаторе}}
== 1 Свойства и структура алгоритма ==

=== Общее описание алгоритма ===
Алгоритм CHAMELEON - алгоритм динамической иерархической кластеризации графа.

Кластеризация - разбиение графа на несколько подграфов таким образом, чтобы объекты внутри одного кластера были максимально близки (схожи), а данные двух различных кластеров максимально различались. Различие и схожесть объектов определяются некоей метрикой, известной заранее. Количество кластеров, на которые будет разбит граф, заранее неизвестно, и зависит от свойств объекта и выбранной метрики. Простейшей возможной метриков является расстояние между точками (если предполагать, что у каждой вершины графа есть координаты).

Алгоритм состоит из 3-х основных этапов:

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

2-й этап заключается в разбиении построенного графа на небольшие кластеры (связные подграфы)

3-й этап состоит в формировании итогового множества кластеров

=== 1.2 Математическое описание алгоритма ===
'''Исходные данные'''

Множество из n объектов и заданные расстояния между объектами. Эта информация позволяет построить матрицу смежности, в которой будут указаны расстояния между соответствующими объектами по некой метрике. Матрица смежности симметрична, на главной диагонали стоят 0, поэтому достаточно хранить <math>\frac{n(n-1)}{2}</math> элементов. Кроме того задаются параметры, влияющие на работу алгоритма - число k, по которому на первом этапе строится граф по принципу k ближайших соседей, и два параметра <math>{T_{ri}}</math> и <math>{T_{rc}}</math>, используемые на третьем этапе для того, что определить, что не нужно далее продолжать кластеризацию.

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

На первом этапе строится граф <math>G(V,E)</math>, <math>V</math> - множество вершин, <math>E</math> - множество ребер, по принципу k ближайших соседей. Изначально граф состоит из множества вершин и пустого множества ребер. Для каждой вершины графа мы выбираем k других вершин, расстояния до которых минимальны (то есть k первых вершин в списке вершин графа, упорядоченных по увеличению расстояния до данной) и добавляем в множество ребер соответствующие ребра, соединяющие данную вершину с каждой из выбранных k вершин.

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

Состоит в итеративном разбиении графа на множество подграфов. Изначально (на первой итерации) разбиение состоит из единственного подграфа. Пусть <math>T</math> - множество подграфов на текущей итерации. Каждая итерация выполняется следующим образом - выбирается максимальный подграф из имеющихся в разбиении по числу вершин (то есть такой подграф <math>G_1(V_1,E_1)\in{T}: \forall {G_2(V_2,E_2)\in{T}: G_2\neq G_1} => |(V_1)|>|(V_2)|</math> ). Выбранный подграф разбивается на 2 подграфа следующим образом - сначала выбираются все разбиения <math>G_2(V_2,E_2)</math> и <math>G_3(V_3,E_3)</math>, такие, что <math>\min(|V_2|,|V_3|)\geq\frac{|V_1|}{4}</math>. Далее среди всех таких разбиений выбирается такое, для которого величина <math>\sum{|E_1^*|},E_1^* </math>- некое ребро, ведущее из вершины, попавшей в <math>G_2</math> в вершину, попавшую в <math>G_3</math>. В определенный момент, когда размер наибольшего кластера <math>|V_b|\leq{q*|V|}</math>, где <math>|V|</math> - количество вершин в изначальном графе, а <math>q</math> - предварительно заданный параметр, процесс дальнейшего разибения прекращается и алгоритм переходи на 3-й этап

'''Третий этап алгоритма:'''

Введем несколько определений:

Абсолютной взаимной связностью пары кластеров называется величина <math>EC_{({C_i},{C_j})}</math>, вычисляется как сумма весов ребер, соединяющих вершина 1-го кластера <math>C_i</math> с вершинами второго кластера <math>C_j</math>. Внутренняя связность кластера <math>E_{C_i}</math>вычисляется как сумма весов ребер, входящих в разделитель, разбивающих <math>C_i</math> на 2 равных подграфа.

Относительная взаимная связность пары кластеров <math>RI_{(C_i,C_j)}</math> вычисляется по формуле <math>RI_{(C_i,C_j)}=\frac{2*|EC_{(C_i,C_j)}|}{|EC_{C_i}|+|EC_{C_j}|}</math>

Абсолютное взаимное сходство пары кластеров <math>S_{E_{(C_i,C_j)}}</math>вычисляется как среднее сходство между связанными вершинами <math>C_i</math> и <math>C_j</math>

Относительное взаимное сходство пары кластеров <math>C_i</math> и <math>C_j</math> обозначается <math>RC_{(C_i,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_j|}{|C_i|+|C_j|}*S_{EC_{(C_j)}}}}</math>

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

Есть два различных подхода анализа сходства.

Первый - для каждой пары кластеров проверяется истинность следующих высказываний

<math>RI(Ci,Cj)\geq{T_{RI}} </math> и <math>RC_{(C_{i},C_{j})}\geq{T_{RC}}</math>

В случае, если для некоторого <math>C_i</math> существует несколько кластеров <math>C_j</math>, удовлетворяющих этим условиям, выбирается такой <math>C_j</math>, что

значение <math>EC_{(C_i,C_j)}</math> максимально.

Процесс останавливается, когда нет кластеров, удовлетворяющих указанным условиям (либо когда остался только 1 кластер)

Второй подход - выбирается такая пара кластеров, что <math>RI_{(C_i,C_j)}*RC^\alpha_{(C_i,C_j)}</math> максимально, где <math>\alpha</math> - заданный заранее параметр.

Процесс останавливается, когда нет кластеров, удовлетворяющих указанным условиям (либо когда остался только 1 кластер)

=== 1.3 Вычислительное ядро алгоритма ===
На первом этапе вычислительное ядро состоит из построения графа k ближайших соседей по исходной матрице смежности (требуется для каждой вершины перебрать всех соседей и выделить k ближайших)

На втором этапе вычислительное ядро состоит из повторяющегося нахождения разбиения графа на два подграфа, удовлетворяющего ранее описанным условиям

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

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

2017-01-23T12:22:09Z

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

{{В инкубаторе}}
== 1 Свойства и структура алгоритма ==

=== 1.1 Общее описание алгоритма ===
Алгоритм CHAMELEON - алгоритм динамической иерархической кластеризации графа.

Кластеризация - разбиение графа на несколько подграфов таким образом, чтобы объекты внутри одного кластера были максимально близки (схожи), а данные двух различных кластеров максимально различались. Различие и схожесть объектов определяются некоей метрикой, известной заранее. Количество кластеров, на которые будет разбит граф, заранее неизвестно, и зависит от свойств объекта и выбранной метрики. Простейшей возможной метриков является расстояние между точками (если предполагать, что у каждой вершины графа есть координаты).

Алгоритм состоит из 3-х основных этапов:

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

2-й этап заключается в разбиении построенного графа на небольшие кластеры (связные подграфы)

3-й этап состоит в формировании итогового множества кластеров

=== 1.2 Математическое описание алгоритма ===
'''Исходные данные'''

Множество из n объектов и заданные расстояния между объектами. Эта информация позволяет построить матрицу смежности, в которой будут указаны расстояния между соответствующими объектами по некой метрике. Матрица смежности симметрична, на главной диагонали стоят 0, поэтому достаточно хранить <math>\frac{n(n-1)}{2}</math> элементов. Кроме того задаются параметры, влияющие на работу алгоритма - число k, по которому на первом этапе строится граф по принципу k ближайших соседей, и два параметра <math>{T_{ri}}</math> и <math>{T_{rc}}</math>, используемые на третьем этапе для того, что определить, что не нужно далее продолжать кластеризацию.

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

На первом этапе строится граф <math>G(V,E)</math>, <math>V</math> - множество вершин, <math>E</math> - множество ребер, по принципу k ближайших соседей. Изначально граф состоит из множества вершин и пустого множества ребер. Для каждой вершины графа мы выбираем k других вершин, расстояния до которых минимальны (то есть k первых вершин в списке вершин графа, упорядоченных по увеличению расстояния до данной) и добавляем в множество ребер соответствующие ребра, соединяющие данную вершину с каждой из выбранных k вершин.

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

Состоит в итеративном разбиении графа на множество подграфов. Изначально (на первой итерации) разбиение состоит из единственного подграфа. Пусть <math>T</math> - множество подграфов на текущей итерации. Каждая итерация выполняется следующим образом - выбирается максимальный подграф из имеющихся в разбиении по числу вершин (то есть такой подграф <math>G_1(V_1,E_1)\in{T}: \forall {G_2(V_2,E_2)\in{T}: G_2\neq G_1} => |(V_1)|>|(V_2)|</math> ). Выбранный подграф разбивается на 2 подграфа следующим образом - сначала выбираются все разбиения <math>G_2(V_2,E_2)</math> и <math>G_3(V_3,E_3)</math>, такие, что <math>\min(|V_2|,|V_3|)\geq\frac{|V_1|}{4}</math>. Далее среди всех таких разбиений выбирается такое, для которого величина <math>\sum{|E_1^*|},E_1^* </math>- некое ребро, ведущее из вершины, попавшей в <math>G_2</math> в вершину, попавшую в <math>G_3</math>. В определенный момент, когда размер наибольшего кластера <math>|V_b|\leq{q*|V|}</math>, где <math>|V|</math> - количество вершин в изначальном графе, а <math>q</math> - предварительно заданный параметр, процесс дальнейшего разибения прекращается и алгоритм переходи на 3-й этап

'''Третий этап алгоритма:'''

Введем несколько определений:

Абсолютной взаимной связностью пары кластеров называется величина <math>EC_{({C_i},{C_j})}</math>, вычисляется как сумма весов ребер, соединяющих вершина 1-го кластера <math>C_i</math> с вершинами второго кластера <math>C_j</math>. Внутренняя связность кластера <math>E_{C_i}</math>вычисляется как сумма весов ребер, входящих в разделитель, разбивающих <math>C_i</math> на 2 равных подграфа.

Относительная взаимная связность пары кластеров <math>RI_{(C_i,C_j)}</math> вычисляется по формуле <math>RI_{(C_i,C_j)}=\frac{2*|EC_{(C_i,C_j)}|}{|EC_{C_i}|+|EC_{C_j}|}</math>

Абсолютное взаимное сходство пары кластеров <math>S_{E_{(C_i,C_j)}}</math>вычисляется как среднее сходство между связанными вершинами <math>C_i</math> и <math>C_j</math>

Относительное взаимное сходство пары кластеров <math>C_i</math> и <math>C_j</math> обозначается <math>RC_{(C_i,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_j|}{|C_i|+|C_j|}*S_{EC_{(C_j)}}}}</math>

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

Есть два различных подхода анализа сходства.

Первый - для каждой пары кластеров проверяется истинность следующих высказываний

<math>RI(Ci,Cj)\geq{T_{RI}} </math> и <math>RC_{(C_{i},C_{j})}\geq{T_{RC}}</math>

В случае, если для некоторого <math>C_i</math> существует несколько кластеров <math>C_j</math>, удовлетворяющих этим условиям, выбирается такой <math>C_j</math>, что

значение <math>EC_{(C_i,C_j)}</math> максимально.

Процесс останавливается, когда нет кластеров, удовлетворяющих указанным условиям (либо когда остался только 1 кластер)

Второй подход - выбирается такая пара кластеров, что <math>RI_{(C_i,C_j)}*RC^\alpha_{(C_i,C_j)}</math> максимально, где <math>\alpha</math> - заданный заранее параметр.

Процесс останавливается, когда нет кластеров, удовлетворяющих указанным условиям (либо когда остался только 1 кластер)

=== 1.3 Вычислительное ядро алгоритма ===
На первом этапе вычислительное ядро состоит из построения графа k ближайших соседей по исходной матрице смежности (требуется для каждой вершины перебрать всех соседей и выделить k ближайших)

На втором этапе вычислительное ядро состоит из повторяющегося нахождения разбиения графа на два подграфа, удовлетворяющего ранее описанным условиям

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

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

2017-01-23T12:05:09Z

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

{{В инкубаторе}}
== 1 Свойства и структура алгоритма ==

=== 1.1 Общее описание алгоритма ===
Алгоритм CHAMELEON - алгоритм динамической иерархической кластеризации графа.

Кластеризация - разбиение графа на несколько подграфов таким образом, чтобы объекты внутри одного кластера были максимально близки (схожи), а данные двух различных кластеров максимально различались. Различие и схожесть объектов определяются некоей метрикой, известной заранее. Количество кластеров, на которые будет разбит граф, заранее неизвестно, и зависит от свойств объекта и выбранной метрики. Простейшей возможной метриков является расстояние между точками (если предполагать, что у каждой вершины графа есть координаты).

Алгоритм состоит из 3-х основных этапов:

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

2-й этап заключается в разбиении построенного графа на небольшие кластеры (связные подграфы)

3-й этап состоит в формировании итогового множества кластеров

=== 1.2 Математическое описание алгоритма ===
'''Исходные данные'''

Множество из n объектов и заданные расстояния между объектами. Эта информация позволяет построить матрицу смежности, в которой будут указаны расстояния между соответствующими объектами по некой метрике. Матрица смежности симметрична, на главной диагонали стоят 0, поэтому достаточно хранить <math>\frac{n(n-1)}{2}</math> элементов. Кроме того задаются параметры, влияющие на работу алгоритма - число k, по которому на первом этапе строится граф по принципу k ближайших соседей, и два параметра <math>{T_{ri}}</math> и <math>{T_{rc}}</math>, используемые на третьем этапе для того, что определить, что не нужно далее продолжать кластеризацию.

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

На первом этапе строится граф <math>G(V,E)</math>, <math>V</math> - множество вершин, <math>E</math> - множество ребер, по принципу k ближайших соседей. Изначально граф состоит из множества вершин и пустого множества ребер. Для каждой вершины графа мы выбираем k других вершин, расстояния до которых минимальны (то есть k первых вершин в списке вершин графа, упорядоченных по увеличению расстояния до данной) и добавляем в множество ребер соответствующие ребра, соединяющие данную вершину с каждой из выбранных k вершин.

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

Состоит в итеративном разбиении графа на множество подграфов. Изначально (на первой итерации) разбиение состоит из единственного подграфа. Пусть <math>T</math> - множество подграфов на текущей итерации. Каждая итерация выполняется следующим образом - выбирается максимальный подграф из имеющихся в разбиении по числу вершин (то есть такой подграф <math>G_1(V_1,E_1)\in{T}: \forall {G_2(V_2,E_2)\in{T}: G_2\neq G_1} => |(V_1)|>|(V_2)|</math> ). Выбранный подграф разбивается на 2 подграфа следующим образом - сначала выбираются все разбиения <math>G_2(V_2,E_2)</math> и <math>G_3(V_3,E_3)</math>, такие, что <math>\min(|V_2|,|V_3|)\geq\frac{|V_1|}{4}</math>. Далее среди всех таких разбиений выбирается такое, для которого величина <math>\sum{|E_1^*|},E_1^* </math>- некое ребро, ведущее из вершины, попавшей в <math>G_2</math> в вершину, попавшую в <math>G_3</math>. В определенный момент, когда размер наибольшего кластера <math>|V_b|\leq{q*|V|}</math>, где <math>|V|</math> - количество вершин в изначальном графе, а <math>q</math> - предварительно заданный параметр, процесс дальнейшего разибения прекращается и алгоритм переходи на 3-й этап

'''Третий этап алгоритма:'''

Введем несколько определений:

Абсолютной взаимной связностью пары кластеров называется величина <math>EC_{({C_i},{C_j})}</math>, вычисляется как сумма весов ребер, соединяющих вершина 1-го кластера <math>C_i</math> с вершинами второго кластера <math>C_j</math>. Внутренняя связность кластера <math>E_{C_i}</math>вычисляется как сумма весов ребер, входящих в разделитель, разбивающих <math>C_i</math> на 2 равных подграфа.

Относительная взаимная связность пары кластеров <math>RI_{(C_i,C_j)}</math> вычисляется по формуле <math>RI_{(C_i,C_j)}=\frac{2*|EC_{(C_i,C_j)}|}{|EC_{C_i}|+|EC_{C_j}|}</math>

Абсолютное взаимное сходство пары кластеров <math>S_{E_{(C_i,C_j)}}</math>вычисляется как среднее сходство между связанными вершинами <math>C_i</math> и <math>C_j</math>

Относительное взаимное сходство пары кластеров <math>C_i</math> и <math>C_j</math> обозначается <math>RC_{(C_i,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_j|}{|C_i|+|C_j|}*S_{EC_{(C_j)}}}}</math>

Есть два различных подхода анализа сходства.

Первый - для каждой пары кластеров проверяется истинность следующих высказываний

{\displaystyle RI(Ci,Cj)\geq {T_{RI}}} и {\displaystyle RC_{(C_{i},C_{j})}\geq {T_{RC}}}

В случае, если для некоторого {\displaystyle C_{i}} существует несколько кластеров {\displaystyle C_{j}} , удовлетворяющих этим условиям, выбирается такой {\displaystyle C_{j}} , что

значение {\displaystyle EC_{(C_{i},C_{j})}} максимально.

Процесс останавливается, когда нет кластеров, удовлетворяющих указанным условиям (либо когда остался только 1 кластер)

Второй подход - выбирается такая пара кластеров, что {\displaystyle RI_{(C_{i},C_{j})}*RC_{(C_{i},C_{j})}^{\alpha }} максимально, где {\displaystyle \alpha } - заданный заранее параметр.

Процесс останавливается, когда нет кластеров, удовлетворяющих указанным условиям (либо когда остался только 1 кластер)

=== 1.3 Вычислительное ядро алгоритма ===
На первом этапе вычислительное ядро состоит из построения графа k ближайших соседей по исходной матрице смежности (требуется для каждой вершины перебрать всех соседей и выделить k ближайших)

На втором этапе вычислительное ядро состоит из повторяющегося нахождения разбиения графа на два подграфа, удовлетворяющего ранее описанным условиям

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